]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added some missing newlines to ends of files (necessary for linear RTF)
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3790 return wxPyTestDisplayAvailable();
3791 }
3792
3793 void wxApp_CleanUp() {
3794 __wxPyCleanup();
3795 }
3796
3797
3798 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3799
3800
3801
3802
3803
3804 SWIGINTERNINLINE PyObject *
3805 SWIG_FromCharPtr(const char *cptr)
3806 {
3807 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3808 }
3809
3810
3811 #if 0 // #ifdef __WXMAC__
3812
3813 // A dummy class that raises an exception if used...
3814 class wxEventLoop
3815 {
3816 public:
3817 wxEventLoop() { wxPyRaiseNotImplemented(); }
3818 int Run() { return 0; }
3819 void Exit(int rc = 0) {}
3820 bool Pending() const { return false; }
3821 bool Dispatch() { return false; }
3822 bool IsRunning() const { return false; }
3823 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3824 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3825 };
3826
3827 #else
3828
3829 #include <wx/evtloop.h>
3830
3831 #endif
3832
3833
3834
3835 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3836 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3837 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3838 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3839 wxWindowList& list = self->GetChildren();
3840 return wxPy_ConvertList(&list);
3841 }
3842 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3843 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3844 #if wxUSE_HOTKEY
3845 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3846 #else
3847 return false;
3848 #endif
3849 }
3850 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3851
3852
3853
3854 return false;
3855
3856 }
3857 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3858 return wxPyGetWinHandle(self);
3859 }
3860 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3861 self->AssociateHandle((WXWidget)handle);
3862 }
3863
3864 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3865 return wxWindow::FindWindowById(id, parent);
3866 }
3867
3868 wxWindow* wxFindWindowByName( const wxString& name,
3869 const wxWindow *parent = NULL ) {
3870 return wxWindow::FindWindowByName(name, parent);
3871 }
3872
3873 wxWindow* wxFindWindowByLabel( const wxString& label,
3874 const wxWindow *parent = NULL ) {
3875 return wxWindow::FindWindowByLabel(label, parent);
3876 }
3877
3878
3879 #ifdef __WXMSW__
3880 #include <wx/msw/private.h> // to get wxGetWindowId
3881 #endif
3882
3883
3884 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3885 #ifdef __WXMSW__
3886 WXHWND hWnd = (WXHWND)_hWnd;
3887 long id = wxGetWindowId(hWnd);
3888 wxWindow* win = new wxWindow;
3889 if (parent)
3890 parent->AddChild(win);
3891 win->SetEventHandler(win);
3892 win->SetHWND(hWnd);
3893 win->SetId(id);
3894 win->SubclassWin(hWnd);
3895 win->AdoptAttributesFromHWND();
3896 win->SetupColours();
3897 return win;
3898 #else
3899 wxPyRaiseNotImplemented();
3900 return NULL;
3901 #endif
3902 }
3903
3904
3905 PyObject* GetTopLevelWindows() {
3906 return wxPy_ConvertList(&wxTopLevelWindows);
3907 }
3908
3909
3910 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3911 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3912 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3913
3914 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3915
3916
3917 SWIGINTERNINLINE int
3918 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3919 {
3920 unsigned long v;
3921 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3922 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3923 return res;
3924 }
3925
3926 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3927 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3928 wxMenuItemList& list = self->GetMenuItems();
3929 return wxPy_ConvertList(&list);
3930 }
3931 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3932 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3933 static const wxString wxPyControlNameStr(wxControlNameStr);
3934 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3935 if (clientData) {
3936 wxPyClientData* data = new wxPyClientData(clientData);
3937 return self->Append(item, data);
3938 } else
3939 return self->Append(item);
3940 }
3941 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3942 if (clientData) {
3943 wxPyClientData* data = new wxPyClientData(clientData);
3944 return self->Insert(item, pos, data);
3945 } else
3946 return self->Insert(item, pos);
3947 }
3948 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3949 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3950 if (data) {
3951 Py_INCREF(data->m_obj);
3952 return data->m_obj;
3953 } else {
3954 Py_INCREF(Py_None);
3955 return Py_None;
3956 }
3957 }
3958 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3959 wxPyClientData* data = new wxPyClientData(clientData);
3960 self->SetClientObject(n, data);
3961 }
3962
3963
3964 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3965 wxPyUserData* data = NULL;
3966 if ( userData ) {
3967 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3968 data = new wxPyUserData(userData);
3969 wxPyEndBlockThreads(blocked);
3970 }
3971 return new wxSizerItem(window, proportion, flag, border, data);
3972 }
3973 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3974 wxPyUserData* data = NULL;
3975 if ( userData ) {
3976 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3977 data = new wxPyUserData(userData);
3978 wxPyEndBlockThreads(blocked);
3979 }
3980 return new wxSizerItem(width, height, proportion, flag, border, data);
3981 }
3982 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3983 wxPyUserData* data = NULL;
3984 if ( userData ) {
3985 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3986 data = new wxPyUserData(userData);
3987 wxPyEndBlockThreads(blocked);
3988 }
3989 return new wxSizerItem(sizer, proportion, flag, border, data);
3990 }
3991
3992 SWIGINTERNINLINE PyObject *
3993 SWIG_From_float (float value)
3994 {
3995 return SWIG_From_double (value);
3996 }
3997
3998 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3999 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4000 if (data) {
4001 Py_INCREF(data->m_obj);
4002 return data->m_obj;
4003 } else {
4004 Py_INCREF(Py_None);
4005 return Py_None;
4006 }
4007 }
4008 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4009 wxPyUserData* data = NULL;
4010 if ( userData ) {
4011 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4012 data = new wxPyUserData(userData);
4013 wxPyEndBlockThreads(blocked);
4014 }
4015 self->SetUserData(data);
4016 }
4017
4018 // Figure out the type of the sizer item
4019
4020 struct wxPySizerItemInfo {
4021 wxPySizerItemInfo()
4022 : window(NULL), sizer(NULL), gotSize(false),
4023 size(wxDefaultSize), gotPos(false), pos(-1)
4024 {}
4025
4026 wxWindow* window;
4027 wxSizer* sizer;
4028 bool gotSize;
4029 wxSize size;
4030 bool gotPos;
4031 int pos;
4032 };
4033
4034 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4035
4036 wxPySizerItemInfo info;
4037 wxSize size;
4038 wxSize* sizePtr = &size;
4039
4040 // Find out what the type of the item is
4041 // try wxWindow
4042 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4043 PyErr_Clear();
4044 info.window = NULL;
4045
4046 // try wxSizer
4047 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4048 PyErr_Clear();
4049 info.sizer = NULL;
4050
4051 // try wxSize or (w,h)
4052 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4053 info.size = *sizePtr;
4054 info.gotSize = true;
4055 }
4056
4057 // or a single int
4058 if (checkIdx && PyInt_Check(item)) {
4059 info.pos = PyInt_AsLong(item);
4060 info.gotPos = true;
4061 }
4062 }
4063 }
4064
4065 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4066 // no expected type, figure out what kind of error message to generate
4067 if ( !checkSize && !checkIdx )
4068 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4069 else if ( checkSize && !checkIdx )
4070 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4071 else if ( !checkSize && checkIdx)
4072 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4073 else
4074 // can this one happen?
4075 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4076 }
4077
4078 return info;
4079 }
4080
4081 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4082 if (!self->GetClientObject())
4083 self->SetClientObject(new wxPyOORClientData(_self));
4084 }
4085 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4086
4087 wxPyUserData* data = NULL;
4088 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4089 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4090 if ( userData && (info.window || info.sizer || info.gotSize) )
4091 data = new wxPyUserData(userData);
4092 if ( info.sizer )
4093 PyObject_SetAttrString(item,"thisown",Py_False);
4094 wxPyEndBlockThreads(blocked);
4095
4096 // Now call the real Add method if a valid item type was found
4097 if ( info.window )
4098 return self->Add(info.window, proportion, flag, border, data);
4099 else if ( info.sizer )
4100 return self->Add(info.sizer, proportion, flag, border, data);
4101 else if (info.gotSize)
4102 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4103 proportion, flag, border, data);
4104 else
4105 return NULL;
4106 }
4107 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4108
4109 wxPyUserData* data = NULL;
4110 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4111 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4112 if ( userData && (info.window || info.sizer || info.gotSize) )
4113 data = new wxPyUserData(userData);
4114 if ( info.sizer )
4115 PyObject_SetAttrString(item,"thisown",Py_False);
4116 wxPyEndBlockThreads(blocked);
4117
4118 // Now call the real Insert method if a valid item type was found
4119 if ( info.window )
4120 return self->Insert(before, info.window, proportion, flag, border, data);
4121 else if ( info.sizer )
4122 return self->Insert(before, info.sizer, proportion, flag, border, data);
4123 else if (info.gotSize)
4124 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4125 proportion, flag, border, data);
4126 else
4127 return NULL;
4128 }
4129 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4130
4131 wxPyUserData* data = NULL;
4132 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4133 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4134 if ( userData && (info.window || info.sizer || info.gotSize) )
4135 data = new wxPyUserData(userData);
4136 if ( info.sizer )
4137 PyObject_SetAttrString(item,"thisown",Py_False);
4138 wxPyEndBlockThreads(blocked);
4139
4140 // Now call the real Prepend method if a valid item type was found
4141 if ( info.window )
4142 return self->Prepend(info.window, proportion, flag, border, data);
4143 else if ( info.sizer )
4144 return self->Prepend(info.sizer, proportion, flag, border, data);
4145 else if (info.gotSize)
4146 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4147 proportion, flag, border, data);
4148 else
4149 return NULL;
4150 }
4151 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4152 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4153 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4154 wxPyEndBlockThreads(blocked);
4155 if ( info.window )
4156 return self->Remove(info.window);
4157 else if ( info.sizer )
4158 return self->Remove(info.sizer);
4159 else if ( info.gotPos )
4160 return self->Remove(info.pos);
4161 else
4162 return false;
4163 }
4164 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4165 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4166 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4167 wxPyEndBlockThreads(blocked);
4168 if ( info.window )
4169 return self->Detach(info.window);
4170 else if ( info.sizer )
4171 return self->Detach(info.sizer);
4172 else if ( info.gotPos )
4173 return self->Detach(info.pos);
4174 else
4175 return false;
4176 }
4177 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4179 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4180 wxPyEndBlockThreads(blocked);
4181 if ( info.window )
4182 return self->GetItem(info.window);
4183 else if ( info.sizer )
4184 return self->GetItem(info.sizer);
4185 else if ( info.gotPos )
4186 return self->GetItem(info.pos);
4187 else
4188 return NULL;
4189 }
4190 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4192 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4193 wxPyEndBlockThreads(blocked);
4194 if ( info.window )
4195 self->SetItemMinSize(info.window, size);
4196 else if ( info.sizer )
4197 self->SetItemMinSize(info.sizer, size);
4198 else if ( info.gotPos )
4199 self->SetItemMinSize(info.pos, size);
4200 }
4201 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4202 wxSizerItemList& list = self->GetChildren();
4203 return wxPy_ConvertList(&list);
4204 }
4205 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4206 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4207 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4208 wxPyEndBlockThreads(blocked);
4209 if ( info.window )
4210 return self->Show(info.window, show, recursive);
4211 else if ( info.sizer )
4212 return self->Show(info.sizer, show, recursive);
4213 else if ( info.gotPos )
4214 return self->Show(info.pos, show);
4215 else
4216 return false;
4217 }
4218 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4219 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4220 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4221 wxPyEndBlockThreads(blocked);
4222 if ( info.window )
4223 return self->IsShown(info.window);
4224 else if ( info.sizer )
4225 return self->IsShown(info.sizer);
4226 else if ( info.gotPos )
4227 return self->IsShown(info.pos);
4228 else
4229 return false;
4230 }
4231
4232 // See pyclasses.h
4233 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4234 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4235 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4236
4237
4238
4239
4240 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4241 {
4242 if (source == Py_None) {
4243 **obj = wxGBPosition(-1,-1);
4244 return true;
4245 }
4246 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4247 }
4248
4249 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4250 {
4251 if (source == Py_None) {
4252 **obj = wxGBSpan(-1,-1);
4253 return true;
4254 }
4255 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4256 }
4257
4258
4259 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4260 wxGBPosition temp, *obj = &temp;
4261 if ( other == Py_None ) return false;
4262 if ( ! wxGBPosition_helper(other, &obj) ) {
4263 PyErr_Clear();
4264 return false;
4265 }
4266 return self->operator==(*obj);
4267 }
4268 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4269 wxGBPosition temp, *obj = &temp;
4270 if ( other == Py_None ) return true;
4271 if ( ! wxGBPosition_helper(other, &obj)) {
4272 PyErr_Clear();
4273 return true;
4274 }
4275 return self->operator!=(*obj);
4276 }
4277 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4278 self->SetRow(row);
4279 self->SetCol(col);
4280 }
4281 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4282 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4283 PyObject* tup = PyTuple_New(2);
4284 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4285 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4286 wxPyEndBlockThreads(blocked);
4287 return tup;
4288 }
4289 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4290 wxGBSpan temp, *obj = &temp;
4291 if ( other == Py_None ) return false;
4292 if ( ! wxGBSpan_helper(other, &obj) ) {
4293 PyErr_Clear();
4294 return false;
4295 }
4296 return self->operator==(*obj);
4297 }
4298 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4299 wxGBSpan temp, *obj = &temp;
4300 if ( other == Py_None ) return true;
4301 if ( ! wxGBSpan_helper(other, &obj)) {
4302 PyErr_Clear();
4303 return true;
4304 }
4305 return self->operator!=(*obj);
4306 }
4307 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4308 self->SetRowspan(rowspan);
4309 self->SetColspan(colspan);
4310 }
4311 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4312 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4313 PyObject* tup = PyTuple_New(2);
4314 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4315 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4316 wxPyEndBlockThreads(blocked);
4317 return tup;
4318 }
4319 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4320 wxPyUserData* data = NULL;
4321 if ( userData ) {
4322 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4323 data = new wxPyUserData(userData);
4324 wxPyEndBlockThreads(blocked);
4325 }
4326 return new wxGBSizerItem(window, pos, span, flag, border, data);
4327 }
4328 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4329 wxPyUserData* data = NULL;
4330 if ( userData ) {
4331 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4332 data = new wxPyUserData(userData);
4333 wxPyEndBlockThreads(blocked);
4334 }
4335 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4336 }
4337 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4338 wxPyUserData* data = NULL;
4339 if ( userData ) {
4340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4341 data = new wxPyUserData(userData);
4342 wxPyEndBlockThreads(blocked);
4343 }
4344 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4345 }
4346 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4347 int row, col;
4348 self->GetEndPos(row, col);
4349 return wxGBPosition(row, col);
4350 }
4351 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4352
4353 wxPyUserData* data = NULL;
4354 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4355 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4356 if ( userData && (info.window || info.sizer || info.gotSize) )
4357 data = new wxPyUserData(userData);
4358 if ( info.sizer )
4359 PyObject_SetAttrString(item,"thisown",Py_False);
4360 wxPyEndBlockThreads(blocked);
4361
4362 // Now call the real Add method if a valid item type was found
4363 if ( info.window )
4364 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4365 else if ( info.sizer )
4366 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4367 else if (info.gotSize)
4368 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4369 pos, span, flag, border, data);
4370 return NULL;
4371 }
4372
4373
4374 #ifdef __cplusplus
4375 extern "C" {
4376 #endif
4377 SWIGINTERN int EmptyString_set(PyObject *) {
4378 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4379 return 1;
4380 }
4381
4382
4383 SWIGINTERN PyObject *EmptyString_get(void) {
4384 PyObject *pyobj = 0;
4385
4386 {
4387 #if wxUSE_UNICODE
4388 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4389 #else
4390 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4391 #endif
4392 }
4393 return pyobj;
4394 }
4395
4396
4397 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4398 PyObject *resultobj = 0;
4399 wxObject *arg1 = (wxObject *) 0 ;
4400 wxString result;
4401 void *argp1 = 0 ;
4402 int res1 = 0 ;
4403 PyObject *swig_obj[1] ;
4404
4405 if (!args) SWIG_fail;
4406 swig_obj[0] = args;
4407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4408 if (!SWIG_IsOK(res1)) {
4409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4410 }
4411 arg1 = reinterpret_cast< wxObject * >(argp1);
4412 {
4413 PyThreadState* __tstate = wxPyBeginAllowThreads();
4414 result = wxObject_GetClassName(arg1);
4415 wxPyEndAllowThreads(__tstate);
4416 if (PyErr_Occurred()) SWIG_fail;
4417 }
4418 {
4419 #if wxUSE_UNICODE
4420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4421 #else
4422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4423 #endif
4424 }
4425 return resultobj;
4426 fail:
4427 return NULL;
4428 }
4429
4430
4431 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4432 PyObject *resultobj = 0;
4433 wxObject *arg1 = (wxObject *) 0 ;
4434 void *argp1 = 0 ;
4435 int res1 = 0 ;
4436 PyObject *swig_obj[1] ;
4437
4438 if (!args) SWIG_fail;
4439 swig_obj[0] = args;
4440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4441 if (!SWIG_IsOK(res1)) {
4442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4443 }
4444 arg1 = reinterpret_cast< wxObject * >(argp1);
4445 {
4446 PyThreadState* __tstate = wxPyBeginAllowThreads();
4447 wxObject_Destroy(arg1);
4448 wxPyEndAllowThreads(__tstate);
4449 if (PyErr_Occurred()) SWIG_fail;
4450 }
4451 resultobj = SWIG_Py_Void();
4452 return resultobj;
4453 fail:
4454 return NULL;
4455 }
4456
4457
4458 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4459 PyObject *obj;
4460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4461 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4462 return SWIG_Py_Void();
4463 }
4464
4465 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4466 PyObject *resultobj = 0;
4467 wxSize *arg1 = (wxSize *) 0 ;
4468 int arg2 ;
4469 void *argp1 = 0 ;
4470 int res1 = 0 ;
4471 int val2 ;
4472 int ecode2 = 0 ;
4473 PyObject *swig_obj[2] ;
4474
4475 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4477 if (!SWIG_IsOK(res1)) {
4478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4479 }
4480 arg1 = reinterpret_cast< wxSize * >(argp1);
4481 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4482 if (!SWIG_IsOK(ecode2)) {
4483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4484 }
4485 arg2 = static_cast< int >(val2);
4486 if (arg1) (arg1)->x = arg2;
4487
4488 resultobj = SWIG_Py_Void();
4489 return resultobj;
4490 fail:
4491 return NULL;
4492 }
4493
4494
4495 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4496 PyObject *resultobj = 0;
4497 wxSize *arg1 = (wxSize *) 0 ;
4498 int result;
4499 void *argp1 = 0 ;
4500 int res1 = 0 ;
4501 PyObject *swig_obj[1] ;
4502
4503 if (!args) SWIG_fail;
4504 swig_obj[0] = args;
4505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4506 if (!SWIG_IsOK(res1)) {
4507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4508 }
4509 arg1 = reinterpret_cast< wxSize * >(argp1);
4510 result = (int) ((arg1)->x);
4511 resultobj = SWIG_From_int(static_cast< int >(result));
4512 return resultobj;
4513 fail:
4514 return NULL;
4515 }
4516
4517
4518 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4519 PyObject *resultobj = 0;
4520 wxSize *arg1 = (wxSize *) 0 ;
4521 int arg2 ;
4522 void *argp1 = 0 ;
4523 int res1 = 0 ;
4524 int val2 ;
4525 int ecode2 = 0 ;
4526 PyObject *swig_obj[2] ;
4527
4528 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4530 if (!SWIG_IsOK(res1)) {
4531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4532 }
4533 arg1 = reinterpret_cast< wxSize * >(argp1);
4534 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4535 if (!SWIG_IsOK(ecode2)) {
4536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4537 }
4538 arg2 = static_cast< int >(val2);
4539 if (arg1) (arg1)->y = arg2;
4540
4541 resultobj = SWIG_Py_Void();
4542 return resultobj;
4543 fail:
4544 return NULL;
4545 }
4546
4547
4548 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4549 PyObject *resultobj = 0;
4550 wxSize *arg1 = (wxSize *) 0 ;
4551 int result;
4552 void *argp1 = 0 ;
4553 int res1 = 0 ;
4554 PyObject *swig_obj[1] ;
4555
4556 if (!args) SWIG_fail;
4557 swig_obj[0] = args;
4558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4559 if (!SWIG_IsOK(res1)) {
4560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4561 }
4562 arg1 = reinterpret_cast< wxSize * >(argp1);
4563 result = (int) ((arg1)->y);
4564 resultobj = SWIG_From_int(static_cast< int >(result));
4565 return resultobj;
4566 fail:
4567 return NULL;
4568 }
4569
4570
4571 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4572 PyObject *resultobj = 0;
4573 int arg1 = (int) 0 ;
4574 int arg2 = (int) 0 ;
4575 wxSize *result = 0 ;
4576 int val1 ;
4577 int ecode1 = 0 ;
4578 int val2 ;
4579 int ecode2 = 0 ;
4580 PyObject * obj0 = 0 ;
4581 PyObject * obj1 = 0 ;
4582 char * kwnames[] = {
4583 (char *) "w",(char *) "h", NULL
4584 };
4585
4586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4587 if (obj0) {
4588 ecode1 = SWIG_AsVal_int(obj0, &val1);
4589 if (!SWIG_IsOK(ecode1)) {
4590 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4591 }
4592 arg1 = static_cast< int >(val1);
4593 }
4594 if (obj1) {
4595 ecode2 = SWIG_AsVal_int(obj1, &val2);
4596 if (!SWIG_IsOK(ecode2)) {
4597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4598 }
4599 arg2 = static_cast< int >(val2);
4600 }
4601 {
4602 PyThreadState* __tstate = wxPyBeginAllowThreads();
4603 result = (wxSize *)new wxSize(arg1,arg2);
4604 wxPyEndAllowThreads(__tstate);
4605 if (PyErr_Occurred()) SWIG_fail;
4606 }
4607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4608 return resultobj;
4609 fail:
4610 return NULL;
4611 }
4612
4613
4614 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4615 PyObject *resultobj = 0;
4616 wxSize *arg1 = (wxSize *) 0 ;
4617 void *argp1 = 0 ;
4618 int res1 = 0 ;
4619 PyObject *swig_obj[1] ;
4620
4621 if (!args) SWIG_fail;
4622 swig_obj[0] = args;
4623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4624 if (!SWIG_IsOK(res1)) {
4625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4626 }
4627 arg1 = reinterpret_cast< wxSize * >(argp1);
4628 {
4629 PyThreadState* __tstate = wxPyBeginAllowThreads();
4630 delete arg1;
4631
4632 wxPyEndAllowThreads(__tstate);
4633 if (PyErr_Occurred()) SWIG_fail;
4634 }
4635 resultobj = SWIG_Py_Void();
4636 return resultobj;
4637 fail:
4638 return NULL;
4639 }
4640
4641
4642 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4643 PyObject *resultobj = 0;
4644 wxSize *arg1 = (wxSize *) 0 ;
4645 PyObject *arg2 = (PyObject *) 0 ;
4646 bool result;
4647 void *argp1 = 0 ;
4648 int res1 = 0 ;
4649 PyObject * obj0 = 0 ;
4650 PyObject * obj1 = 0 ;
4651 char * kwnames[] = {
4652 (char *) "self",(char *) "other", NULL
4653 };
4654
4655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4657 if (!SWIG_IsOK(res1)) {
4658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4659 }
4660 arg1 = reinterpret_cast< wxSize * >(argp1);
4661 arg2 = obj1;
4662 {
4663 result = (bool)wxSize___eq__(arg1,arg2);
4664 if (PyErr_Occurred()) SWIG_fail;
4665 }
4666 {
4667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4668 }
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4676 PyObject *resultobj = 0;
4677 wxSize *arg1 = (wxSize *) 0 ;
4678 PyObject *arg2 = (PyObject *) 0 ;
4679 bool result;
4680 void *argp1 = 0 ;
4681 int res1 = 0 ;
4682 PyObject * obj0 = 0 ;
4683 PyObject * obj1 = 0 ;
4684 char * kwnames[] = {
4685 (char *) "self",(char *) "other", NULL
4686 };
4687
4688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4690 if (!SWIG_IsOK(res1)) {
4691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4692 }
4693 arg1 = reinterpret_cast< wxSize * >(argp1);
4694 arg2 = obj1;
4695 {
4696 result = (bool)wxSize___ne__(arg1,arg2);
4697 if (PyErr_Occurred()) SWIG_fail;
4698 }
4699 {
4700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4701 }
4702 return resultobj;
4703 fail:
4704 return NULL;
4705 }
4706
4707
4708 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4709 PyObject *resultobj = 0;
4710 wxSize *arg1 = (wxSize *) 0 ;
4711 wxSize *arg2 = 0 ;
4712 wxSize result;
4713 void *argp1 = 0 ;
4714 int res1 = 0 ;
4715 wxSize temp2 ;
4716 PyObject * obj0 = 0 ;
4717 PyObject * obj1 = 0 ;
4718 char * kwnames[] = {
4719 (char *) "self",(char *) "sz", NULL
4720 };
4721
4722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4724 if (!SWIG_IsOK(res1)) {
4725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4726 }
4727 arg1 = reinterpret_cast< wxSize * >(argp1);
4728 {
4729 arg2 = &temp2;
4730 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4731 }
4732 {
4733 PyThreadState* __tstate = wxPyBeginAllowThreads();
4734 result = (arg1)->operator +((wxSize const &)*arg2);
4735 wxPyEndAllowThreads(__tstate);
4736 if (PyErr_Occurred()) SWIG_fail;
4737 }
4738 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4739 return resultobj;
4740 fail:
4741 return NULL;
4742 }
4743
4744
4745 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4746 PyObject *resultobj = 0;
4747 wxSize *arg1 = (wxSize *) 0 ;
4748 wxSize *arg2 = 0 ;
4749 wxSize result;
4750 void *argp1 = 0 ;
4751 int res1 = 0 ;
4752 wxSize temp2 ;
4753 PyObject * obj0 = 0 ;
4754 PyObject * obj1 = 0 ;
4755 char * kwnames[] = {
4756 (char *) "self",(char *) "sz", NULL
4757 };
4758
4759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4761 if (!SWIG_IsOK(res1)) {
4762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4763 }
4764 arg1 = reinterpret_cast< wxSize * >(argp1);
4765 {
4766 arg2 = &temp2;
4767 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4768 }
4769 {
4770 PyThreadState* __tstate = wxPyBeginAllowThreads();
4771 result = (arg1)->operator -((wxSize const &)*arg2);
4772 wxPyEndAllowThreads(__tstate);
4773 if (PyErr_Occurred()) SWIG_fail;
4774 }
4775 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4776 return resultobj;
4777 fail:
4778 return NULL;
4779 }
4780
4781
4782 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4783 PyObject *resultobj = 0;
4784 wxSize *arg1 = (wxSize *) 0 ;
4785 wxSize *arg2 = 0 ;
4786 void *argp1 = 0 ;
4787 int res1 = 0 ;
4788 wxSize temp2 ;
4789 PyObject * obj0 = 0 ;
4790 PyObject * obj1 = 0 ;
4791 char * kwnames[] = {
4792 (char *) "self",(char *) "sz", NULL
4793 };
4794
4795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4797 if (!SWIG_IsOK(res1)) {
4798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4799 }
4800 arg1 = reinterpret_cast< wxSize * >(argp1);
4801 {
4802 arg2 = &temp2;
4803 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4804 }
4805 {
4806 PyThreadState* __tstate = wxPyBeginAllowThreads();
4807 (arg1)->IncTo((wxSize const &)*arg2);
4808 wxPyEndAllowThreads(__tstate);
4809 if (PyErr_Occurred()) SWIG_fail;
4810 }
4811 resultobj = SWIG_Py_Void();
4812 return resultobj;
4813 fail:
4814 return NULL;
4815 }
4816
4817
4818 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4819 PyObject *resultobj = 0;
4820 wxSize *arg1 = (wxSize *) 0 ;
4821 wxSize *arg2 = 0 ;
4822 void *argp1 = 0 ;
4823 int res1 = 0 ;
4824 wxSize temp2 ;
4825 PyObject * obj0 = 0 ;
4826 PyObject * obj1 = 0 ;
4827 char * kwnames[] = {
4828 (char *) "self",(char *) "sz", NULL
4829 };
4830
4831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4833 if (!SWIG_IsOK(res1)) {
4834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4835 }
4836 arg1 = reinterpret_cast< wxSize * >(argp1);
4837 {
4838 arg2 = &temp2;
4839 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4840 }
4841 {
4842 PyThreadState* __tstate = wxPyBeginAllowThreads();
4843 (arg1)->DecTo((wxSize const &)*arg2);
4844 wxPyEndAllowThreads(__tstate);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 resultobj = SWIG_Py_Void();
4848 return resultobj;
4849 fail:
4850 return NULL;
4851 }
4852
4853
4854 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4855 PyObject *resultobj = 0;
4856 wxSize *arg1 = (wxSize *) 0 ;
4857 int arg2 ;
4858 int arg3 ;
4859 void *argp1 = 0 ;
4860 int res1 = 0 ;
4861 int val2 ;
4862 int ecode2 = 0 ;
4863 int val3 ;
4864 int ecode3 = 0 ;
4865 PyObject * obj0 = 0 ;
4866 PyObject * obj1 = 0 ;
4867 PyObject * obj2 = 0 ;
4868 char * kwnames[] = {
4869 (char *) "self",(char *) "dx",(char *) "dy", NULL
4870 };
4871
4872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4874 if (!SWIG_IsOK(res1)) {
4875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4876 }
4877 arg1 = reinterpret_cast< wxSize * >(argp1);
4878 ecode2 = SWIG_AsVal_int(obj1, &val2);
4879 if (!SWIG_IsOK(ecode2)) {
4880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4881 }
4882 arg2 = static_cast< int >(val2);
4883 ecode3 = SWIG_AsVal_int(obj2, &val3);
4884 if (!SWIG_IsOK(ecode3)) {
4885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4886 }
4887 arg3 = static_cast< int >(val3);
4888 {
4889 PyThreadState* __tstate = wxPyBeginAllowThreads();
4890 (arg1)->IncBy(arg2,arg3);
4891 wxPyEndAllowThreads(__tstate);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 resultobj = SWIG_Py_Void();
4895 return resultobj;
4896 fail:
4897 return NULL;
4898 }
4899
4900
4901 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4902 PyObject *resultobj = 0;
4903 wxSize *arg1 = (wxSize *) 0 ;
4904 int arg2 ;
4905 int arg3 ;
4906 void *argp1 = 0 ;
4907 int res1 = 0 ;
4908 int val2 ;
4909 int ecode2 = 0 ;
4910 int val3 ;
4911 int ecode3 = 0 ;
4912 PyObject * obj0 = 0 ;
4913 PyObject * obj1 = 0 ;
4914 PyObject * obj2 = 0 ;
4915 char * kwnames[] = {
4916 (char *) "self",(char *) "dx",(char *) "dy", NULL
4917 };
4918
4919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4921 if (!SWIG_IsOK(res1)) {
4922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4923 }
4924 arg1 = reinterpret_cast< wxSize * >(argp1);
4925 ecode2 = SWIG_AsVal_int(obj1, &val2);
4926 if (!SWIG_IsOK(ecode2)) {
4927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
4928 }
4929 arg2 = static_cast< int >(val2);
4930 ecode3 = SWIG_AsVal_int(obj2, &val3);
4931 if (!SWIG_IsOK(ecode3)) {
4932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
4933 }
4934 arg3 = static_cast< int >(val3);
4935 {
4936 PyThreadState* __tstate = wxPyBeginAllowThreads();
4937 (arg1)->DecBy(arg2,arg3);
4938 wxPyEndAllowThreads(__tstate);
4939 if (PyErr_Occurred()) SWIG_fail;
4940 }
4941 resultobj = SWIG_Py_Void();
4942 return resultobj;
4943 fail:
4944 return NULL;
4945 }
4946
4947
4948 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4949 PyObject *resultobj = 0;
4950 wxSize *arg1 = (wxSize *) 0 ;
4951 float arg2 ;
4952 float arg3 ;
4953 void *argp1 = 0 ;
4954 int res1 = 0 ;
4955 float val2 ;
4956 int ecode2 = 0 ;
4957 float val3 ;
4958 int ecode3 = 0 ;
4959 PyObject * obj0 = 0 ;
4960 PyObject * obj1 = 0 ;
4961 PyObject * obj2 = 0 ;
4962 char * kwnames[] = {
4963 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4964 };
4965
4966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4968 if (!SWIG_IsOK(res1)) {
4969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4970 }
4971 arg1 = reinterpret_cast< wxSize * >(argp1);
4972 ecode2 = SWIG_AsVal_float(obj1, &val2);
4973 if (!SWIG_IsOK(ecode2)) {
4974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4975 }
4976 arg2 = static_cast< float >(val2);
4977 ecode3 = SWIG_AsVal_float(obj2, &val3);
4978 if (!SWIG_IsOK(ecode3)) {
4979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4980 }
4981 arg3 = static_cast< float >(val3);
4982 {
4983 PyThreadState* __tstate = wxPyBeginAllowThreads();
4984 (arg1)->Scale(arg2,arg3);
4985 wxPyEndAllowThreads(__tstate);
4986 if (PyErr_Occurred()) SWIG_fail;
4987 }
4988 resultobj = SWIG_Py_Void();
4989 return resultobj;
4990 fail:
4991 return NULL;
4992 }
4993
4994
4995 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4996 PyObject *resultobj = 0;
4997 wxSize *arg1 = (wxSize *) 0 ;
4998 int arg2 ;
4999 int arg3 ;
5000 void *argp1 = 0 ;
5001 int res1 = 0 ;
5002 int val2 ;
5003 int ecode2 = 0 ;
5004 int val3 ;
5005 int ecode3 = 0 ;
5006 PyObject * obj0 = 0 ;
5007 PyObject * obj1 = 0 ;
5008 PyObject * obj2 = 0 ;
5009 char * kwnames[] = {
5010 (char *) "self",(char *) "w",(char *) "h", NULL
5011 };
5012
5013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5015 if (!SWIG_IsOK(res1)) {
5016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5017 }
5018 arg1 = reinterpret_cast< wxSize * >(argp1);
5019 ecode2 = SWIG_AsVal_int(obj1, &val2);
5020 if (!SWIG_IsOK(ecode2)) {
5021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5022 }
5023 arg2 = static_cast< int >(val2);
5024 ecode3 = SWIG_AsVal_int(obj2, &val3);
5025 if (!SWIG_IsOK(ecode3)) {
5026 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5027 }
5028 arg3 = static_cast< int >(val3);
5029 {
5030 PyThreadState* __tstate = wxPyBeginAllowThreads();
5031 (arg1)->Set(arg2,arg3);
5032 wxPyEndAllowThreads(__tstate);
5033 if (PyErr_Occurred()) SWIG_fail;
5034 }
5035 resultobj = SWIG_Py_Void();
5036 return resultobj;
5037 fail:
5038 return NULL;
5039 }
5040
5041
5042 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5043 PyObject *resultobj = 0;
5044 wxSize *arg1 = (wxSize *) 0 ;
5045 int arg2 ;
5046 void *argp1 = 0 ;
5047 int res1 = 0 ;
5048 int val2 ;
5049 int ecode2 = 0 ;
5050 PyObject * obj0 = 0 ;
5051 PyObject * obj1 = 0 ;
5052 char * kwnames[] = {
5053 (char *) "self",(char *) "w", NULL
5054 };
5055
5056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5058 if (!SWIG_IsOK(res1)) {
5059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5060 }
5061 arg1 = reinterpret_cast< wxSize * >(argp1);
5062 ecode2 = SWIG_AsVal_int(obj1, &val2);
5063 if (!SWIG_IsOK(ecode2)) {
5064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5065 }
5066 arg2 = static_cast< int >(val2);
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 (arg1)->SetWidth(arg2);
5070 wxPyEndAllowThreads(__tstate);
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 resultobj = SWIG_Py_Void();
5074 return resultobj;
5075 fail:
5076 return NULL;
5077 }
5078
5079
5080 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5081 PyObject *resultobj = 0;
5082 wxSize *arg1 = (wxSize *) 0 ;
5083 int arg2 ;
5084 void *argp1 = 0 ;
5085 int res1 = 0 ;
5086 int val2 ;
5087 int ecode2 = 0 ;
5088 PyObject * obj0 = 0 ;
5089 PyObject * obj1 = 0 ;
5090 char * kwnames[] = {
5091 (char *) "self",(char *) "h", NULL
5092 };
5093
5094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5096 if (!SWIG_IsOK(res1)) {
5097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5098 }
5099 arg1 = reinterpret_cast< wxSize * >(argp1);
5100 ecode2 = SWIG_AsVal_int(obj1, &val2);
5101 if (!SWIG_IsOK(ecode2)) {
5102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5103 }
5104 arg2 = static_cast< int >(val2);
5105 {
5106 PyThreadState* __tstate = wxPyBeginAllowThreads();
5107 (arg1)->SetHeight(arg2);
5108 wxPyEndAllowThreads(__tstate);
5109 if (PyErr_Occurred()) SWIG_fail;
5110 }
5111 resultobj = SWIG_Py_Void();
5112 return resultobj;
5113 fail:
5114 return NULL;
5115 }
5116
5117
5118 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5119 PyObject *resultobj = 0;
5120 wxSize *arg1 = (wxSize *) 0 ;
5121 int result;
5122 void *argp1 = 0 ;
5123 int res1 = 0 ;
5124 PyObject *swig_obj[1] ;
5125
5126 if (!args) SWIG_fail;
5127 swig_obj[0] = args;
5128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5129 if (!SWIG_IsOK(res1)) {
5130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5131 }
5132 arg1 = reinterpret_cast< wxSize * >(argp1);
5133 {
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 result = (int)((wxSize const *)arg1)->GetWidth();
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 resultobj = SWIG_From_int(static_cast< int >(result));
5140 return resultobj;
5141 fail:
5142 return NULL;
5143 }
5144
5145
5146 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5147 PyObject *resultobj = 0;
5148 wxSize *arg1 = (wxSize *) 0 ;
5149 int result;
5150 void *argp1 = 0 ;
5151 int res1 = 0 ;
5152 PyObject *swig_obj[1] ;
5153
5154 if (!args) SWIG_fail;
5155 swig_obj[0] = args;
5156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5157 if (!SWIG_IsOK(res1)) {
5158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5159 }
5160 arg1 = reinterpret_cast< wxSize * >(argp1);
5161 {
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 result = (int)((wxSize const *)arg1)->GetHeight();
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 resultobj = SWIG_From_int(static_cast< int >(result));
5168 return resultobj;
5169 fail:
5170 return NULL;
5171 }
5172
5173
5174 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5175 PyObject *resultobj = 0;
5176 wxSize *arg1 = (wxSize *) 0 ;
5177 bool result;
5178 void *argp1 = 0 ;
5179 int res1 = 0 ;
5180 PyObject *swig_obj[1] ;
5181
5182 if (!args) SWIG_fail;
5183 swig_obj[0] = args;
5184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5185 if (!SWIG_IsOK(res1)) {
5186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5187 }
5188 arg1 = reinterpret_cast< wxSize * >(argp1);
5189 {
5190 PyThreadState* __tstate = wxPyBeginAllowThreads();
5191 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5192 wxPyEndAllowThreads(__tstate);
5193 if (PyErr_Occurred()) SWIG_fail;
5194 }
5195 {
5196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5197 }
5198 return resultobj;
5199 fail:
5200 return NULL;
5201 }
5202
5203
5204 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5205 PyObject *resultobj = 0;
5206 wxSize *arg1 = (wxSize *) 0 ;
5207 wxSize *arg2 = 0 ;
5208 void *argp1 = 0 ;
5209 int res1 = 0 ;
5210 wxSize temp2 ;
5211 PyObject * obj0 = 0 ;
5212 PyObject * obj1 = 0 ;
5213 char * kwnames[] = {
5214 (char *) "self",(char *) "size", NULL
5215 };
5216
5217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5219 if (!SWIG_IsOK(res1)) {
5220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5221 }
5222 arg1 = reinterpret_cast< wxSize * >(argp1);
5223 {
5224 arg2 = &temp2;
5225 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5226 }
5227 {
5228 PyThreadState* __tstate = wxPyBeginAllowThreads();
5229 (arg1)->SetDefaults((wxSize const &)*arg2);
5230 wxPyEndAllowThreads(__tstate);
5231 if (PyErr_Occurred()) SWIG_fail;
5232 }
5233 resultobj = SWIG_Py_Void();
5234 return resultobj;
5235 fail:
5236 return NULL;
5237 }
5238
5239
5240 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5241 PyObject *resultobj = 0;
5242 wxSize *arg1 = (wxSize *) 0 ;
5243 PyObject *result = 0 ;
5244 void *argp1 = 0 ;
5245 int res1 = 0 ;
5246 PyObject *swig_obj[1] ;
5247
5248 if (!args) SWIG_fail;
5249 swig_obj[0] = args;
5250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5251 if (!SWIG_IsOK(res1)) {
5252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5253 }
5254 arg1 = reinterpret_cast< wxSize * >(argp1);
5255 {
5256 PyThreadState* __tstate = wxPyBeginAllowThreads();
5257 result = (PyObject *)wxSize_Get(arg1);
5258 wxPyEndAllowThreads(__tstate);
5259 if (PyErr_Occurred()) SWIG_fail;
5260 }
5261 resultobj = result;
5262 return resultobj;
5263 fail:
5264 return NULL;
5265 }
5266
5267
5268 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5269 PyObject *obj;
5270 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5271 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5272 return SWIG_Py_Void();
5273 }
5274
5275 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5276 return SWIG_Python_InitShadowInstance(args);
5277 }
5278
5279 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5280 PyObject *resultobj = 0;
5281 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5282 double arg2 ;
5283 void *argp1 = 0 ;
5284 int res1 = 0 ;
5285 double val2 ;
5286 int ecode2 = 0 ;
5287 PyObject *swig_obj[2] ;
5288
5289 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5291 if (!SWIG_IsOK(res1)) {
5292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5293 }
5294 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5295 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5296 if (!SWIG_IsOK(ecode2)) {
5297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5298 }
5299 arg2 = static_cast< double >(val2);
5300 if (arg1) (arg1)->x = arg2;
5301
5302 resultobj = SWIG_Py_Void();
5303 return resultobj;
5304 fail:
5305 return NULL;
5306 }
5307
5308
5309 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5310 PyObject *resultobj = 0;
5311 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5312 double result;
5313 void *argp1 = 0 ;
5314 int res1 = 0 ;
5315 PyObject *swig_obj[1] ;
5316
5317 if (!args) SWIG_fail;
5318 swig_obj[0] = args;
5319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5320 if (!SWIG_IsOK(res1)) {
5321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5322 }
5323 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5324 result = (double) ((arg1)->x);
5325 resultobj = SWIG_From_double(static_cast< double >(result));
5326 return resultobj;
5327 fail:
5328 return NULL;
5329 }
5330
5331
5332 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5333 PyObject *resultobj = 0;
5334 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5335 double arg2 ;
5336 void *argp1 = 0 ;
5337 int res1 = 0 ;
5338 double val2 ;
5339 int ecode2 = 0 ;
5340 PyObject *swig_obj[2] ;
5341
5342 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5344 if (!SWIG_IsOK(res1)) {
5345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5346 }
5347 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5348 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5349 if (!SWIG_IsOK(ecode2)) {
5350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5351 }
5352 arg2 = static_cast< double >(val2);
5353 if (arg1) (arg1)->y = arg2;
5354
5355 resultobj = SWIG_Py_Void();
5356 return resultobj;
5357 fail:
5358 return NULL;
5359 }
5360
5361
5362 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5363 PyObject *resultobj = 0;
5364 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5365 double result;
5366 void *argp1 = 0 ;
5367 int res1 = 0 ;
5368 PyObject *swig_obj[1] ;
5369
5370 if (!args) SWIG_fail;
5371 swig_obj[0] = args;
5372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5373 if (!SWIG_IsOK(res1)) {
5374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5375 }
5376 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5377 result = (double) ((arg1)->y);
5378 resultobj = SWIG_From_double(static_cast< double >(result));
5379 return resultobj;
5380 fail:
5381 return NULL;
5382 }
5383
5384
5385 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5386 PyObject *resultobj = 0;
5387 double arg1 = (double) 0.0 ;
5388 double arg2 = (double) 0.0 ;
5389 wxRealPoint *result = 0 ;
5390 double val1 ;
5391 int ecode1 = 0 ;
5392 double val2 ;
5393 int ecode2 = 0 ;
5394 PyObject * obj0 = 0 ;
5395 PyObject * obj1 = 0 ;
5396 char * kwnames[] = {
5397 (char *) "x",(char *) "y", NULL
5398 };
5399
5400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5401 if (obj0) {
5402 ecode1 = SWIG_AsVal_double(obj0, &val1);
5403 if (!SWIG_IsOK(ecode1)) {
5404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5405 }
5406 arg1 = static_cast< double >(val1);
5407 }
5408 if (obj1) {
5409 ecode2 = SWIG_AsVal_double(obj1, &val2);
5410 if (!SWIG_IsOK(ecode2)) {
5411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5412 }
5413 arg2 = static_cast< double >(val2);
5414 }
5415 {
5416 PyThreadState* __tstate = wxPyBeginAllowThreads();
5417 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5418 wxPyEndAllowThreads(__tstate);
5419 if (PyErr_Occurred()) SWIG_fail;
5420 }
5421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5422 return resultobj;
5423 fail:
5424 return NULL;
5425 }
5426
5427
5428 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5429 PyObject *resultobj = 0;
5430 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5431 void *argp1 = 0 ;
5432 int res1 = 0 ;
5433 PyObject *swig_obj[1] ;
5434
5435 if (!args) SWIG_fail;
5436 swig_obj[0] = args;
5437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5438 if (!SWIG_IsOK(res1)) {
5439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5440 }
5441 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5442 {
5443 PyThreadState* __tstate = wxPyBeginAllowThreads();
5444 delete arg1;
5445
5446 wxPyEndAllowThreads(__tstate);
5447 if (PyErr_Occurred()) SWIG_fail;
5448 }
5449 resultobj = SWIG_Py_Void();
5450 return resultobj;
5451 fail:
5452 return NULL;
5453 }
5454
5455
5456 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5457 PyObject *resultobj = 0;
5458 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5459 PyObject *arg2 = (PyObject *) 0 ;
5460 bool result;
5461 void *argp1 = 0 ;
5462 int res1 = 0 ;
5463 PyObject * obj0 = 0 ;
5464 PyObject * obj1 = 0 ;
5465 char * kwnames[] = {
5466 (char *) "self",(char *) "other", NULL
5467 };
5468
5469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5471 if (!SWIG_IsOK(res1)) {
5472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5473 }
5474 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5475 arg2 = obj1;
5476 {
5477 result = (bool)wxRealPoint___eq__(arg1,arg2);
5478 if (PyErr_Occurred()) SWIG_fail;
5479 }
5480 {
5481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5482 }
5483 return resultobj;
5484 fail:
5485 return NULL;
5486 }
5487
5488
5489 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5490 PyObject *resultobj = 0;
5491 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5492 PyObject *arg2 = (PyObject *) 0 ;
5493 bool result;
5494 void *argp1 = 0 ;
5495 int res1 = 0 ;
5496 PyObject * obj0 = 0 ;
5497 PyObject * obj1 = 0 ;
5498 char * kwnames[] = {
5499 (char *) "self",(char *) "other", NULL
5500 };
5501
5502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5504 if (!SWIG_IsOK(res1)) {
5505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5506 }
5507 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5508 arg2 = obj1;
5509 {
5510 result = (bool)wxRealPoint___ne__(arg1,arg2);
5511 if (PyErr_Occurred()) SWIG_fail;
5512 }
5513 {
5514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5515 }
5516 return resultobj;
5517 fail:
5518 return NULL;
5519 }
5520
5521
5522 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5523 PyObject *resultobj = 0;
5524 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5525 wxRealPoint *arg2 = 0 ;
5526 wxRealPoint result;
5527 void *argp1 = 0 ;
5528 int res1 = 0 ;
5529 wxRealPoint temp2 ;
5530 PyObject * obj0 = 0 ;
5531 PyObject * obj1 = 0 ;
5532 char * kwnames[] = {
5533 (char *) "self",(char *) "pt", NULL
5534 };
5535
5536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5538 if (!SWIG_IsOK(res1)) {
5539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5540 }
5541 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5542 {
5543 arg2 = &temp2;
5544 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5545 }
5546 {
5547 PyThreadState* __tstate = wxPyBeginAllowThreads();
5548 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5549 wxPyEndAllowThreads(__tstate);
5550 if (PyErr_Occurred()) SWIG_fail;
5551 }
5552 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5553 return resultobj;
5554 fail:
5555 return NULL;
5556 }
5557
5558
5559 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5560 PyObject *resultobj = 0;
5561 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5562 wxRealPoint *arg2 = 0 ;
5563 wxRealPoint result;
5564 void *argp1 = 0 ;
5565 int res1 = 0 ;
5566 wxRealPoint temp2 ;
5567 PyObject * obj0 = 0 ;
5568 PyObject * obj1 = 0 ;
5569 char * kwnames[] = {
5570 (char *) "self",(char *) "pt", NULL
5571 };
5572
5573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5575 if (!SWIG_IsOK(res1)) {
5576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5577 }
5578 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5579 {
5580 arg2 = &temp2;
5581 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5582 }
5583 {
5584 PyThreadState* __tstate = wxPyBeginAllowThreads();
5585 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5586 wxPyEndAllowThreads(__tstate);
5587 if (PyErr_Occurred()) SWIG_fail;
5588 }
5589 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5590 return resultobj;
5591 fail:
5592 return NULL;
5593 }
5594
5595
5596 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5597 PyObject *resultobj = 0;
5598 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5599 double arg2 ;
5600 double arg3 ;
5601 void *argp1 = 0 ;
5602 int res1 = 0 ;
5603 double val2 ;
5604 int ecode2 = 0 ;
5605 double val3 ;
5606 int ecode3 = 0 ;
5607 PyObject * obj0 = 0 ;
5608 PyObject * obj1 = 0 ;
5609 PyObject * obj2 = 0 ;
5610 char * kwnames[] = {
5611 (char *) "self",(char *) "x",(char *) "y", NULL
5612 };
5613
5614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5616 if (!SWIG_IsOK(res1)) {
5617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5618 }
5619 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5620 ecode2 = SWIG_AsVal_double(obj1, &val2);
5621 if (!SWIG_IsOK(ecode2)) {
5622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5623 }
5624 arg2 = static_cast< double >(val2);
5625 ecode3 = SWIG_AsVal_double(obj2, &val3);
5626 if (!SWIG_IsOK(ecode3)) {
5627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5628 }
5629 arg3 = static_cast< double >(val3);
5630 {
5631 PyThreadState* __tstate = wxPyBeginAllowThreads();
5632 wxRealPoint_Set(arg1,arg2,arg3);
5633 wxPyEndAllowThreads(__tstate);
5634 if (PyErr_Occurred()) SWIG_fail;
5635 }
5636 resultobj = SWIG_Py_Void();
5637 return resultobj;
5638 fail:
5639 return NULL;
5640 }
5641
5642
5643 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5644 PyObject *resultobj = 0;
5645 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5646 PyObject *result = 0 ;
5647 void *argp1 = 0 ;
5648 int res1 = 0 ;
5649 PyObject *swig_obj[1] ;
5650
5651 if (!args) SWIG_fail;
5652 swig_obj[0] = args;
5653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5654 if (!SWIG_IsOK(res1)) {
5655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5656 }
5657 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5658 {
5659 PyThreadState* __tstate = wxPyBeginAllowThreads();
5660 result = (PyObject *)wxRealPoint_Get(arg1);
5661 wxPyEndAllowThreads(__tstate);
5662 if (PyErr_Occurred()) SWIG_fail;
5663 }
5664 resultobj = result;
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5672 PyObject *obj;
5673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5674 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5675 return SWIG_Py_Void();
5676 }
5677
5678 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5679 return SWIG_Python_InitShadowInstance(args);
5680 }
5681
5682 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5683 PyObject *resultobj = 0;
5684 wxPoint *arg1 = (wxPoint *) 0 ;
5685 int arg2 ;
5686 void *argp1 = 0 ;
5687 int res1 = 0 ;
5688 int val2 ;
5689 int ecode2 = 0 ;
5690 PyObject *swig_obj[2] ;
5691
5692 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5694 if (!SWIG_IsOK(res1)) {
5695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5696 }
5697 arg1 = reinterpret_cast< wxPoint * >(argp1);
5698 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5699 if (!SWIG_IsOK(ecode2)) {
5700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5701 }
5702 arg2 = static_cast< int >(val2);
5703 if (arg1) (arg1)->x = arg2;
5704
5705 resultobj = SWIG_Py_Void();
5706 return resultobj;
5707 fail:
5708 return NULL;
5709 }
5710
5711
5712 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5713 PyObject *resultobj = 0;
5714 wxPoint *arg1 = (wxPoint *) 0 ;
5715 int result;
5716 void *argp1 = 0 ;
5717 int res1 = 0 ;
5718 PyObject *swig_obj[1] ;
5719
5720 if (!args) SWIG_fail;
5721 swig_obj[0] = args;
5722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5723 if (!SWIG_IsOK(res1)) {
5724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5725 }
5726 arg1 = reinterpret_cast< wxPoint * >(argp1);
5727 result = (int) ((arg1)->x);
5728 resultobj = SWIG_From_int(static_cast< int >(result));
5729 return resultobj;
5730 fail:
5731 return NULL;
5732 }
5733
5734
5735 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5736 PyObject *resultobj = 0;
5737 wxPoint *arg1 = (wxPoint *) 0 ;
5738 int arg2 ;
5739 void *argp1 = 0 ;
5740 int res1 = 0 ;
5741 int val2 ;
5742 int ecode2 = 0 ;
5743 PyObject *swig_obj[2] ;
5744
5745 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5747 if (!SWIG_IsOK(res1)) {
5748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5749 }
5750 arg1 = reinterpret_cast< wxPoint * >(argp1);
5751 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5752 if (!SWIG_IsOK(ecode2)) {
5753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5754 }
5755 arg2 = static_cast< int >(val2);
5756 if (arg1) (arg1)->y = arg2;
5757
5758 resultobj = SWIG_Py_Void();
5759 return resultobj;
5760 fail:
5761 return NULL;
5762 }
5763
5764
5765 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5766 PyObject *resultobj = 0;
5767 wxPoint *arg1 = (wxPoint *) 0 ;
5768 int result;
5769 void *argp1 = 0 ;
5770 int res1 = 0 ;
5771 PyObject *swig_obj[1] ;
5772
5773 if (!args) SWIG_fail;
5774 swig_obj[0] = args;
5775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5776 if (!SWIG_IsOK(res1)) {
5777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5778 }
5779 arg1 = reinterpret_cast< wxPoint * >(argp1);
5780 result = (int) ((arg1)->y);
5781 resultobj = SWIG_From_int(static_cast< int >(result));
5782 return resultobj;
5783 fail:
5784 return NULL;
5785 }
5786
5787
5788 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5789 PyObject *resultobj = 0;
5790 int arg1 = (int) 0 ;
5791 int arg2 = (int) 0 ;
5792 wxPoint *result = 0 ;
5793 int val1 ;
5794 int ecode1 = 0 ;
5795 int val2 ;
5796 int ecode2 = 0 ;
5797 PyObject * obj0 = 0 ;
5798 PyObject * obj1 = 0 ;
5799 char * kwnames[] = {
5800 (char *) "x",(char *) "y", NULL
5801 };
5802
5803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5804 if (obj0) {
5805 ecode1 = SWIG_AsVal_int(obj0, &val1);
5806 if (!SWIG_IsOK(ecode1)) {
5807 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5808 }
5809 arg1 = static_cast< int >(val1);
5810 }
5811 if (obj1) {
5812 ecode2 = SWIG_AsVal_int(obj1, &val2);
5813 if (!SWIG_IsOK(ecode2)) {
5814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5815 }
5816 arg2 = static_cast< int >(val2);
5817 }
5818 {
5819 PyThreadState* __tstate = wxPyBeginAllowThreads();
5820 result = (wxPoint *)new wxPoint(arg1,arg2);
5821 wxPyEndAllowThreads(__tstate);
5822 if (PyErr_Occurred()) SWIG_fail;
5823 }
5824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5825 return resultobj;
5826 fail:
5827 return NULL;
5828 }
5829
5830
5831 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5832 PyObject *resultobj = 0;
5833 wxPoint *arg1 = (wxPoint *) 0 ;
5834 void *argp1 = 0 ;
5835 int res1 = 0 ;
5836 PyObject *swig_obj[1] ;
5837
5838 if (!args) SWIG_fail;
5839 swig_obj[0] = args;
5840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5841 if (!SWIG_IsOK(res1)) {
5842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5843 }
5844 arg1 = reinterpret_cast< wxPoint * >(argp1);
5845 {
5846 PyThreadState* __tstate = wxPyBeginAllowThreads();
5847 delete arg1;
5848
5849 wxPyEndAllowThreads(__tstate);
5850 if (PyErr_Occurred()) SWIG_fail;
5851 }
5852 resultobj = SWIG_Py_Void();
5853 return resultobj;
5854 fail:
5855 return NULL;
5856 }
5857
5858
5859 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5860 PyObject *resultobj = 0;
5861 wxPoint *arg1 = (wxPoint *) 0 ;
5862 PyObject *arg2 = (PyObject *) 0 ;
5863 bool result;
5864 void *argp1 = 0 ;
5865 int res1 = 0 ;
5866 PyObject * obj0 = 0 ;
5867 PyObject * obj1 = 0 ;
5868 char * kwnames[] = {
5869 (char *) "self",(char *) "other", NULL
5870 };
5871
5872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5874 if (!SWIG_IsOK(res1)) {
5875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5876 }
5877 arg1 = reinterpret_cast< wxPoint * >(argp1);
5878 arg2 = obj1;
5879 {
5880 result = (bool)wxPoint___eq__(arg1,arg2);
5881 if (PyErr_Occurred()) SWIG_fail;
5882 }
5883 {
5884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5885 }
5886 return resultobj;
5887 fail:
5888 return NULL;
5889 }
5890
5891
5892 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5893 PyObject *resultobj = 0;
5894 wxPoint *arg1 = (wxPoint *) 0 ;
5895 PyObject *arg2 = (PyObject *) 0 ;
5896 bool result;
5897 void *argp1 = 0 ;
5898 int res1 = 0 ;
5899 PyObject * obj0 = 0 ;
5900 PyObject * obj1 = 0 ;
5901 char * kwnames[] = {
5902 (char *) "self",(char *) "other", NULL
5903 };
5904
5905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5907 if (!SWIG_IsOK(res1)) {
5908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5909 }
5910 arg1 = reinterpret_cast< wxPoint * >(argp1);
5911 arg2 = obj1;
5912 {
5913 result = (bool)wxPoint___ne__(arg1,arg2);
5914 if (PyErr_Occurred()) SWIG_fail;
5915 }
5916 {
5917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5918 }
5919 return resultobj;
5920 fail:
5921 return NULL;
5922 }
5923
5924
5925 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5926 PyObject *resultobj = 0;
5927 wxPoint *arg1 = (wxPoint *) 0 ;
5928 wxPoint *arg2 = 0 ;
5929 wxPoint result;
5930 void *argp1 = 0 ;
5931 int res1 = 0 ;
5932 wxPoint temp2 ;
5933 PyObject * obj0 = 0 ;
5934 PyObject * obj1 = 0 ;
5935 char * kwnames[] = {
5936 (char *) "self",(char *) "pt", NULL
5937 };
5938
5939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5941 if (!SWIG_IsOK(res1)) {
5942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5943 }
5944 arg1 = reinterpret_cast< wxPoint * >(argp1);
5945 {
5946 arg2 = &temp2;
5947 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5948 }
5949 {
5950 PyThreadState* __tstate = wxPyBeginAllowThreads();
5951 result = (arg1)->operator +((wxPoint const &)*arg2);
5952 wxPyEndAllowThreads(__tstate);
5953 if (PyErr_Occurred()) SWIG_fail;
5954 }
5955 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5956 return resultobj;
5957 fail:
5958 return NULL;
5959 }
5960
5961
5962 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5963 PyObject *resultobj = 0;
5964 wxPoint *arg1 = (wxPoint *) 0 ;
5965 wxPoint *arg2 = 0 ;
5966 wxPoint result;
5967 void *argp1 = 0 ;
5968 int res1 = 0 ;
5969 wxPoint temp2 ;
5970 PyObject * obj0 = 0 ;
5971 PyObject * obj1 = 0 ;
5972 char * kwnames[] = {
5973 (char *) "self",(char *) "pt", NULL
5974 };
5975
5976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5978 if (!SWIG_IsOK(res1)) {
5979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5980 }
5981 arg1 = reinterpret_cast< wxPoint * >(argp1);
5982 {
5983 arg2 = &temp2;
5984 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5985 }
5986 {
5987 PyThreadState* __tstate = wxPyBeginAllowThreads();
5988 result = (arg1)->operator -((wxPoint const &)*arg2);
5989 wxPyEndAllowThreads(__tstate);
5990 if (PyErr_Occurred()) SWIG_fail;
5991 }
5992 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5993 return resultobj;
5994 fail:
5995 return NULL;
5996 }
5997
5998
5999 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6000 PyObject *resultobj = 0;
6001 wxPoint *arg1 = (wxPoint *) 0 ;
6002 wxPoint *arg2 = 0 ;
6003 wxPoint *result = 0 ;
6004 void *argp1 = 0 ;
6005 int res1 = 0 ;
6006 wxPoint temp2 ;
6007 PyObject * obj0 = 0 ;
6008 PyObject * obj1 = 0 ;
6009 char * kwnames[] = {
6010 (char *) "self",(char *) "pt", NULL
6011 };
6012
6013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6015 if (!SWIG_IsOK(res1)) {
6016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6017 }
6018 arg1 = reinterpret_cast< wxPoint * >(argp1);
6019 {
6020 arg2 = &temp2;
6021 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6022 }
6023 {
6024 PyThreadState* __tstate = wxPyBeginAllowThreads();
6025 {
6026 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6027 result = (wxPoint *) &_result_ref;
6028 }
6029 wxPyEndAllowThreads(__tstate);
6030 if (PyErr_Occurred()) SWIG_fail;
6031 }
6032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6033 return resultobj;
6034 fail:
6035 return NULL;
6036 }
6037
6038
6039 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6040 PyObject *resultobj = 0;
6041 wxPoint *arg1 = (wxPoint *) 0 ;
6042 wxPoint *arg2 = 0 ;
6043 wxPoint *result = 0 ;
6044 void *argp1 = 0 ;
6045 int res1 = 0 ;
6046 wxPoint temp2 ;
6047 PyObject * obj0 = 0 ;
6048 PyObject * obj1 = 0 ;
6049 char * kwnames[] = {
6050 (char *) "self",(char *) "pt", NULL
6051 };
6052
6053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6055 if (!SWIG_IsOK(res1)) {
6056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6057 }
6058 arg1 = reinterpret_cast< wxPoint * >(argp1);
6059 {
6060 arg2 = &temp2;
6061 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6062 }
6063 {
6064 PyThreadState* __tstate = wxPyBeginAllowThreads();
6065 {
6066 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6067 result = (wxPoint *) &_result_ref;
6068 }
6069 wxPyEndAllowThreads(__tstate);
6070 if (PyErr_Occurred()) SWIG_fail;
6071 }
6072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6073 return resultobj;
6074 fail:
6075 return NULL;
6076 }
6077
6078
6079 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6080 PyObject *resultobj = 0;
6081 wxPoint *arg1 = (wxPoint *) 0 ;
6082 long arg2 ;
6083 long arg3 ;
6084 void *argp1 = 0 ;
6085 int res1 = 0 ;
6086 long val2 ;
6087 int ecode2 = 0 ;
6088 long val3 ;
6089 int ecode3 = 0 ;
6090 PyObject * obj0 = 0 ;
6091 PyObject * obj1 = 0 ;
6092 PyObject * obj2 = 0 ;
6093 char * kwnames[] = {
6094 (char *) "self",(char *) "x",(char *) "y", NULL
6095 };
6096
6097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6099 if (!SWIG_IsOK(res1)) {
6100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6101 }
6102 arg1 = reinterpret_cast< wxPoint * >(argp1);
6103 ecode2 = SWIG_AsVal_long(obj1, &val2);
6104 if (!SWIG_IsOK(ecode2)) {
6105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6106 }
6107 arg2 = static_cast< long >(val2);
6108 ecode3 = SWIG_AsVal_long(obj2, &val3);
6109 if (!SWIG_IsOK(ecode3)) {
6110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6111 }
6112 arg3 = static_cast< long >(val3);
6113 {
6114 PyThreadState* __tstate = wxPyBeginAllowThreads();
6115 wxPoint_Set(arg1,arg2,arg3);
6116 wxPyEndAllowThreads(__tstate);
6117 if (PyErr_Occurred()) SWIG_fail;
6118 }
6119 resultobj = SWIG_Py_Void();
6120 return resultobj;
6121 fail:
6122 return NULL;
6123 }
6124
6125
6126 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6127 PyObject *resultobj = 0;
6128 wxPoint *arg1 = (wxPoint *) 0 ;
6129 PyObject *result = 0 ;
6130 void *argp1 = 0 ;
6131 int res1 = 0 ;
6132 PyObject *swig_obj[1] ;
6133
6134 if (!args) SWIG_fail;
6135 swig_obj[0] = args;
6136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6137 if (!SWIG_IsOK(res1)) {
6138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6139 }
6140 arg1 = reinterpret_cast< wxPoint * >(argp1);
6141 {
6142 PyThreadState* __tstate = wxPyBeginAllowThreads();
6143 result = (PyObject *)wxPoint_Get(arg1);
6144 wxPyEndAllowThreads(__tstate);
6145 if (PyErr_Occurred()) SWIG_fail;
6146 }
6147 resultobj = result;
6148 return resultobj;
6149 fail:
6150 return NULL;
6151 }
6152
6153
6154 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6155 PyObject *obj;
6156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6157 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6158 return SWIG_Py_Void();
6159 }
6160
6161 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6162 return SWIG_Python_InitShadowInstance(args);
6163 }
6164
6165 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6166 PyObject *resultobj = 0;
6167 int arg1 = (int) 0 ;
6168 int arg2 = (int) 0 ;
6169 int arg3 = (int) 0 ;
6170 int arg4 = (int) 0 ;
6171 wxRect *result = 0 ;
6172 int val1 ;
6173 int ecode1 = 0 ;
6174 int val2 ;
6175 int ecode2 = 0 ;
6176 int val3 ;
6177 int ecode3 = 0 ;
6178 int val4 ;
6179 int ecode4 = 0 ;
6180 PyObject * obj0 = 0 ;
6181 PyObject * obj1 = 0 ;
6182 PyObject * obj2 = 0 ;
6183 PyObject * obj3 = 0 ;
6184 char * kwnames[] = {
6185 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6186 };
6187
6188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6189 if (obj0) {
6190 ecode1 = SWIG_AsVal_int(obj0, &val1);
6191 if (!SWIG_IsOK(ecode1)) {
6192 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6193 }
6194 arg1 = static_cast< int >(val1);
6195 }
6196 if (obj1) {
6197 ecode2 = SWIG_AsVal_int(obj1, &val2);
6198 if (!SWIG_IsOK(ecode2)) {
6199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6200 }
6201 arg2 = static_cast< int >(val2);
6202 }
6203 if (obj2) {
6204 ecode3 = SWIG_AsVal_int(obj2, &val3);
6205 if (!SWIG_IsOK(ecode3)) {
6206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6207 }
6208 arg3 = static_cast< int >(val3);
6209 }
6210 if (obj3) {
6211 ecode4 = SWIG_AsVal_int(obj3, &val4);
6212 if (!SWIG_IsOK(ecode4)) {
6213 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6214 }
6215 arg4 = static_cast< int >(val4);
6216 }
6217 {
6218 PyThreadState* __tstate = wxPyBeginAllowThreads();
6219 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6220 wxPyEndAllowThreads(__tstate);
6221 if (PyErr_Occurred()) SWIG_fail;
6222 }
6223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6224 return resultobj;
6225 fail:
6226 return NULL;
6227 }
6228
6229
6230 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6231 PyObject *resultobj = 0;
6232 wxPoint *arg1 = 0 ;
6233 wxPoint *arg2 = 0 ;
6234 wxRect *result = 0 ;
6235 wxPoint temp1 ;
6236 wxPoint temp2 ;
6237 PyObject * obj0 = 0 ;
6238 PyObject * obj1 = 0 ;
6239 char * kwnames[] = {
6240 (char *) "topLeft",(char *) "bottomRight", NULL
6241 };
6242
6243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6244 {
6245 arg1 = &temp1;
6246 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6247 }
6248 {
6249 arg2 = &temp2;
6250 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6251 }
6252 {
6253 PyThreadState* __tstate = wxPyBeginAllowThreads();
6254 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6255 wxPyEndAllowThreads(__tstate);
6256 if (PyErr_Occurred()) SWIG_fail;
6257 }
6258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6259 return resultobj;
6260 fail:
6261 return NULL;
6262 }
6263
6264
6265 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6266 PyObject *resultobj = 0;
6267 wxPoint *arg1 = 0 ;
6268 wxSize *arg2 = 0 ;
6269 wxRect *result = 0 ;
6270 wxPoint temp1 ;
6271 wxSize temp2 ;
6272 PyObject * obj0 = 0 ;
6273 PyObject * obj1 = 0 ;
6274 char * kwnames[] = {
6275 (char *) "pos",(char *) "size", NULL
6276 };
6277
6278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6279 {
6280 arg1 = &temp1;
6281 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6282 }
6283 {
6284 arg2 = &temp2;
6285 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6286 }
6287 {
6288 PyThreadState* __tstate = wxPyBeginAllowThreads();
6289 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6290 wxPyEndAllowThreads(__tstate);
6291 if (PyErr_Occurred()) SWIG_fail;
6292 }
6293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6294 return resultobj;
6295 fail:
6296 return NULL;
6297 }
6298
6299
6300 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6301 PyObject *resultobj = 0;
6302 wxSize *arg1 = 0 ;
6303 wxRect *result = 0 ;
6304 wxSize temp1 ;
6305 PyObject * obj0 = 0 ;
6306 char * kwnames[] = {
6307 (char *) "size", NULL
6308 };
6309
6310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6311 {
6312 arg1 = &temp1;
6313 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6314 }
6315 {
6316 PyThreadState* __tstate = wxPyBeginAllowThreads();
6317 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6318 wxPyEndAllowThreads(__tstate);
6319 if (PyErr_Occurred()) SWIG_fail;
6320 }
6321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6322 return resultobj;
6323 fail:
6324 return NULL;
6325 }
6326
6327
6328 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6329 PyObject *resultobj = 0;
6330 wxRect *arg1 = (wxRect *) 0 ;
6331 void *argp1 = 0 ;
6332 int res1 = 0 ;
6333 PyObject *swig_obj[1] ;
6334
6335 if (!args) SWIG_fail;
6336 swig_obj[0] = args;
6337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6338 if (!SWIG_IsOK(res1)) {
6339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6340 }
6341 arg1 = reinterpret_cast< wxRect * >(argp1);
6342 {
6343 PyThreadState* __tstate = wxPyBeginAllowThreads();
6344 delete arg1;
6345
6346 wxPyEndAllowThreads(__tstate);
6347 if (PyErr_Occurred()) SWIG_fail;
6348 }
6349 resultobj = SWIG_Py_Void();
6350 return resultobj;
6351 fail:
6352 return NULL;
6353 }
6354
6355
6356 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6357 PyObject *resultobj = 0;
6358 wxRect *arg1 = (wxRect *) 0 ;
6359 int result;
6360 void *argp1 = 0 ;
6361 int res1 = 0 ;
6362 PyObject *swig_obj[1] ;
6363
6364 if (!args) SWIG_fail;
6365 swig_obj[0] = args;
6366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6367 if (!SWIG_IsOK(res1)) {
6368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6369 }
6370 arg1 = reinterpret_cast< wxRect * >(argp1);
6371 {
6372 PyThreadState* __tstate = wxPyBeginAllowThreads();
6373 result = (int)((wxRect const *)arg1)->GetX();
6374 wxPyEndAllowThreads(__tstate);
6375 if (PyErr_Occurred()) SWIG_fail;
6376 }
6377 resultobj = SWIG_From_int(static_cast< int >(result));
6378 return resultobj;
6379 fail:
6380 return NULL;
6381 }
6382
6383
6384 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6385 PyObject *resultobj = 0;
6386 wxRect *arg1 = (wxRect *) 0 ;
6387 int arg2 ;
6388 void *argp1 = 0 ;
6389 int res1 = 0 ;
6390 int val2 ;
6391 int ecode2 = 0 ;
6392 PyObject * obj0 = 0 ;
6393 PyObject * obj1 = 0 ;
6394 char * kwnames[] = {
6395 (char *) "self",(char *) "x", NULL
6396 };
6397
6398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6400 if (!SWIG_IsOK(res1)) {
6401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6402 }
6403 arg1 = reinterpret_cast< wxRect * >(argp1);
6404 ecode2 = SWIG_AsVal_int(obj1, &val2);
6405 if (!SWIG_IsOK(ecode2)) {
6406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6407 }
6408 arg2 = static_cast< int >(val2);
6409 {
6410 PyThreadState* __tstate = wxPyBeginAllowThreads();
6411 (arg1)->SetX(arg2);
6412 wxPyEndAllowThreads(__tstate);
6413 if (PyErr_Occurred()) SWIG_fail;
6414 }
6415 resultobj = SWIG_Py_Void();
6416 return resultobj;
6417 fail:
6418 return NULL;
6419 }
6420
6421
6422 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6423 PyObject *resultobj = 0;
6424 wxRect *arg1 = (wxRect *) 0 ;
6425 int result;
6426 void *argp1 = 0 ;
6427 int res1 = 0 ;
6428 PyObject *swig_obj[1] ;
6429
6430 if (!args) SWIG_fail;
6431 swig_obj[0] = args;
6432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6433 if (!SWIG_IsOK(res1)) {
6434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6435 }
6436 arg1 = reinterpret_cast< wxRect * >(argp1);
6437 {
6438 PyThreadState* __tstate = wxPyBeginAllowThreads();
6439 result = (int)(arg1)->GetY();
6440 wxPyEndAllowThreads(__tstate);
6441 if (PyErr_Occurred()) SWIG_fail;
6442 }
6443 resultobj = SWIG_From_int(static_cast< int >(result));
6444 return resultobj;
6445 fail:
6446 return NULL;
6447 }
6448
6449
6450 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6451 PyObject *resultobj = 0;
6452 wxRect *arg1 = (wxRect *) 0 ;
6453 int arg2 ;
6454 void *argp1 = 0 ;
6455 int res1 = 0 ;
6456 int val2 ;
6457 int ecode2 = 0 ;
6458 PyObject * obj0 = 0 ;
6459 PyObject * obj1 = 0 ;
6460 char * kwnames[] = {
6461 (char *) "self",(char *) "y", NULL
6462 };
6463
6464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6466 if (!SWIG_IsOK(res1)) {
6467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6468 }
6469 arg1 = reinterpret_cast< wxRect * >(argp1);
6470 ecode2 = SWIG_AsVal_int(obj1, &val2);
6471 if (!SWIG_IsOK(ecode2)) {
6472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6473 }
6474 arg2 = static_cast< int >(val2);
6475 {
6476 PyThreadState* __tstate = wxPyBeginAllowThreads();
6477 (arg1)->SetY(arg2);
6478 wxPyEndAllowThreads(__tstate);
6479 if (PyErr_Occurred()) SWIG_fail;
6480 }
6481 resultobj = SWIG_Py_Void();
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
6488 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6489 PyObject *resultobj = 0;
6490 wxRect *arg1 = (wxRect *) 0 ;
6491 int result;
6492 void *argp1 = 0 ;
6493 int res1 = 0 ;
6494 PyObject *swig_obj[1] ;
6495
6496 if (!args) SWIG_fail;
6497 swig_obj[0] = args;
6498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6499 if (!SWIG_IsOK(res1)) {
6500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6501 }
6502 arg1 = reinterpret_cast< wxRect * >(argp1);
6503 {
6504 PyThreadState* __tstate = wxPyBeginAllowThreads();
6505 result = (int)((wxRect const *)arg1)->GetWidth();
6506 wxPyEndAllowThreads(__tstate);
6507 if (PyErr_Occurred()) SWIG_fail;
6508 }
6509 resultobj = SWIG_From_int(static_cast< int >(result));
6510 return resultobj;
6511 fail:
6512 return NULL;
6513 }
6514
6515
6516 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6517 PyObject *resultobj = 0;
6518 wxRect *arg1 = (wxRect *) 0 ;
6519 int arg2 ;
6520 void *argp1 = 0 ;
6521 int res1 = 0 ;
6522 int val2 ;
6523 int ecode2 = 0 ;
6524 PyObject * obj0 = 0 ;
6525 PyObject * obj1 = 0 ;
6526 char * kwnames[] = {
6527 (char *) "self",(char *) "w", NULL
6528 };
6529
6530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6532 if (!SWIG_IsOK(res1)) {
6533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6534 }
6535 arg1 = reinterpret_cast< wxRect * >(argp1);
6536 ecode2 = SWIG_AsVal_int(obj1, &val2);
6537 if (!SWIG_IsOK(ecode2)) {
6538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6539 }
6540 arg2 = static_cast< int >(val2);
6541 {
6542 PyThreadState* __tstate = wxPyBeginAllowThreads();
6543 (arg1)->SetWidth(arg2);
6544 wxPyEndAllowThreads(__tstate);
6545 if (PyErr_Occurred()) SWIG_fail;
6546 }
6547 resultobj = SWIG_Py_Void();
6548 return resultobj;
6549 fail:
6550 return NULL;
6551 }
6552
6553
6554 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6555 PyObject *resultobj = 0;
6556 wxRect *arg1 = (wxRect *) 0 ;
6557 int result;
6558 void *argp1 = 0 ;
6559 int res1 = 0 ;
6560 PyObject *swig_obj[1] ;
6561
6562 if (!args) SWIG_fail;
6563 swig_obj[0] = args;
6564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6565 if (!SWIG_IsOK(res1)) {
6566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6567 }
6568 arg1 = reinterpret_cast< wxRect * >(argp1);
6569 {
6570 PyThreadState* __tstate = wxPyBeginAllowThreads();
6571 result = (int)((wxRect const *)arg1)->GetHeight();
6572 wxPyEndAllowThreads(__tstate);
6573 if (PyErr_Occurred()) SWIG_fail;
6574 }
6575 resultobj = SWIG_From_int(static_cast< int >(result));
6576 return resultobj;
6577 fail:
6578 return NULL;
6579 }
6580
6581
6582 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6583 PyObject *resultobj = 0;
6584 wxRect *arg1 = (wxRect *) 0 ;
6585 int arg2 ;
6586 void *argp1 = 0 ;
6587 int res1 = 0 ;
6588 int val2 ;
6589 int ecode2 = 0 ;
6590 PyObject * obj0 = 0 ;
6591 PyObject * obj1 = 0 ;
6592 char * kwnames[] = {
6593 (char *) "self",(char *) "h", NULL
6594 };
6595
6596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6598 if (!SWIG_IsOK(res1)) {
6599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6600 }
6601 arg1 = reinterpret_cast< wxRect * >(argp1);
6602 ecode2 = SWIG_AsVal_int(obj1, &val2);
6603 if (!SWIG_IsOK(ecode2)) {
6604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6605 }
6606 arg2 = static_cast< int >(val2);
6607 {
6608 PyThreadState* __tstate = wxPyBeginAllowThreads();
6609 (arg1)->SetHeight(arg2);
6610 wxPyEndAllowThreads(__tstate);
6611 if (PyErr_Occurred()) SWIG_fail;
6612 }
6613 resultobj = SWIG_Py_Void();
6614 return resultobj;
6615 fail:
6616 return NULL;
6617 }
6618
6619
6620 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6621 PyObject *resultobj = 0;
6622 wxRect *arg1 = (wxRect *) 0 ;
6623 wxPoint result;
6624 void *argp1 = 0 ;
6625 int res1 = 0 ;
6626 PyObject *swig_obj[1] ;
6627
6628 if (!args) SWIG_fail;
6629 swig_obj[0] = args;
6630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6631 if (!SWIG_IsOK(res1)) {
6632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6633 }
6634 arg1 = reinterpret_cast< wxRect * >(argp1);
6635 {
6636 PyThreadState* __tstate = wxPyBeginAllowThreads();
6637 result = ((wxRect const *)arg1)->GetPosition();
6638 wxPyEndAllowThreads(__tstate);
6639 if (PyErr_Occurred()) SWIG_fail;
6640 }
6641 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6642 return resultobj;
6643 fail:
6644 return NULL;
6645 }
6646
6647
6648 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6649 PyObject *resultobj = 0;
6650 wxRect *arg1 = (wxRect *) 0 ;
6651 wxPoint *arg2 = 0 ;
6652 void *argp1 = 0 ;
6653 int res1 = 0 ;
6654 wxPoint temp2 ;
6655 PyObject * obj0 = 0 ;
6656 PyObject * obj1 = 0 ;
6657 char * kwnames[] = {
6658 (char *) "self",(char *) "p", NULL
6659 };
6660
6661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6663 if (!SWIG_IsOK(res1)) {
6664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6665 }
6666 arg1 = reinterpret_cast< wxRect * >(argp1);
6667 {
6668 arg2 = &temp2;
6669 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6670 }
6671 {
6672 PyThreadState* __tstate = wxPyBeginAllowThreads();
6673 (arg1)->SetPosition((wxPoint const &)*arg2);
6674 wxPyEndAllowThreads(__tstate);
6675 if (PyErr_Occurred()) SWIG_fail;
6676 }
6677 resultobj = SWIG_Py_Void();
6678 return resultobj;
6679 fail:
6680 return NULL;
6681 }
6682
6683
6684 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6685 PyObject *resultobj = 0;
6686 wxRect *arg1 = (wxRect *) 0 ;
6687 wxSize result;
6688 void *argp1 = 0 ;
6689 int res1 = 0 ;
6690 PyObject *swig_obj[1] ;
6691
6692 if (!args) SWIG_fail;
6693 swig_obj[0] = args;
6694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6695 if (!SWIG_IsOK(res1)) {
6696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6697 }
6698 arg1 = reinterpret_cast< wxRect * >(argp1);
6699 {
6700 PyThreadState* __tstate = wxPyBeginAllowThreads();
6701 result = ((wxRect const *)arg1)->GetSize();
6702 wxPyEndAllowThreads(__tstate);
6703 if (PyErr_Occurred()) SWIG_fail;
6704 }
6705 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6706 return resultobj;
6707 fail:
6708 return NULL;
6709 }
6710
6711
6712 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6713 PyObject *resultobj = 0;
6714 wxRect *arg1 = (wxRect *) 0 ;
6715 wxSize *arg2 = 0 ;
6716 void *argp1 = 0 ;
6717 int res1 = 0 ;
6718 wxSize temp2 ;
6719 PyObject * obj0 = 0 ;
6720 PyObject * obj1 = 0 ;
6721 char * kwnames[] = {
6722 (char *) "self",(char *) "s", NULL
6723 };
6724
6725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6727 if (!SWIG_IsOK(res1)) {
6728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6729 }
6730 arg1 = reinterpret_cast< wxRect * >(argp1);
6731 {
6732 arg2 = &temp2;
6733 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6734 }
6735 {
6736 PyThreadState* __tstate = wxPyBeginAllowThreads();
6737 (arg1)->SetSize((wxSize const &)*arg2);
6738 wxPyEndAllowThreads(__tstate);
6739 if (PyErr_Occurred()) SWIG_fail;
6740 }
6741 resultobj = SWIG_Py_Void();
6742 return resultobj;
6743 fail:
6744 return NULL;
6745 }
6746
6747
6748 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6749 PyObject *resultobj = 0;
6750 wxRect *arg1 = (wxRect *) 0 ;
6751 bool result;
6752 void *argp1 = 0 ;
6753 int res1 = 0 ;
6754 PyObject *swig_obj[1] ;
6755
6756 if (!args) SWIG_fail;
6757 swig_obj[0] = args;
6758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6759 if (!SWIG_IsOK(res1)) {
6760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6761 }
6762 arg1 = reinterpret_cast< wxRect * >(argp1);
6763 {
6764 PyThreadState* __tstate = wxPyBeginAllowThreads();
6765 result = (bool)((wxRect const *)arg1)->IsEmpty();
6766 wxPyEndAllowThreads(__tstate);
6767 if (PyErr_Occurred()) SWIG_fail;
6768 }
6769 {
6770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6771 }
6772 return resultobj;
6773 fail:
6774 return NULL;
6775 }
6776
6777
6778 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6779 PyObject *resultobj = 0;
6780 wxRect *arg1 = (wxRect *) 0 ;
6781 wxPoint result;
6782 void *argp1 = 0 ;
6783 int res1 = 0 ;
6784 PyObject *swig_obj[1] ;
6785
6786 if (!args) SWIG_fail;
6787 swig_obj[0] = args;
6788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6789 if (!SWIG_IsOK(res1)) {
6790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6791 }
6792 arg1 = reinterpret_cast< wxRect * >(argp1);
6793 {
6794 PyThreadState* __tstate = wxPyBeginAllowThreads();
6795 result = ((wxRect const *)arg1)->GetTopLeft();
6796 wxPyEndAllowThreads(__tstate);
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6800 return resultobj;
6801 fail:
6802 return NULL;
6803 }
6804
6805
6806 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6807 PyObject *resultobj = 0;
6808 wxRect *arg1 = (wxRect *) 0 ;
6809 wxPoint *arg2 = 0 ;
6810 void *argp1 = 0 ;
6811 int res1 = 0 ;
6812 wxPoint temp2 ;
6813 PyObject * obj0 = 0 ;
6814 PyObject * obj1 = 0 ;
6815 char * kwnames[] = {
6816 (char *) "self",(char *) "p", NULL
6817 };
6818
6819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6821 if (!SWIG_IsOK(res1)) {
6822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6823 }
6824 arg1 = reinterpret_cast< wxRect * >(argp1);
6825 {
6826 arg2 = &temp2;
6827 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6828 }
6829 {
6830 PyThreadState* __tstate = wxPyBeginAllowThreads();
6831 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6832 wxPyEndAllowThreads(__tstate);
6833 if (PyErr_Occurred()) SWIG_fail;
6834 }
6835 resultobj = SWIG_Py_Void();
6836 return resultobj;
6837 fail:
6838 return NULL;
6839 }
6840
6841
6842 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6843 PyObject *resultobj = 0;
6844 wxRect *arg1 = (wxRect *) 0 ;
6845 wxPoint result;
6846 void *argp1 = 0 ;
6847 int res1 = 0 ;
6848 PyObject *swig_obj[1] ;
6849
6850 if (!args) SWIG_fail;
6851 swig_obj[0] = args;
6852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6853 if (!SWIG_IsOK(res1)) {
6854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6855 }
6856 arg1 = reinterpret_cast< wxRect * >(argp1);
6857 {
6858 PyThreadState* __tstate = wxPyBeginAllowThreads();
6859 result = ((wxRect const *)arg1)->GetBottomRight();
6860 wxPyEndAllowThreads(__tstate);
6861 if (PyErr_Occurred()) SWIG_fail;
6862 }
6863 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6864 return resultobj;
6865 fail:
6866 return NULL;
6867 }
6868
6869
6870 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6871 PyObject *resultobj = 0;
6872 wxRect *arg1 = (wxRect *) 0 ;
6873 wxPoint *arg2 = 0 ;
6874 void *argp1 = 0 ;
6875 int res1 = 0 ;
6876 wxPoint temp2 ;
6877 PyObject * obj0 = 0 ;
6878 PyObject * obj1 = 0 ;
6879 char * kwnames[] = {
6880 (char *) "self",(char *) "p", NULL
6881 };
6882
6883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6885 if (!SWIG_IsOK(res1)) {
6886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6887 }
6888 arg1 = reinterpret_cast< wxRect * >(argp1);
6889 {
6890 arg2 = &temp2;
6891 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6892 }
6893 {
6894 PyThreadState* __tstate = wxPyBeginAllowThreads();
6895 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6896 wxPyEndAllowThreads(__tstate);
6897 if (PyErr_Occurred()) SWIG_fail;
6898 }
6899 resultobj = SWIG_Py_Void();
6900 return resultobj;
6901 fail:
6902 return NULL;
6903 }
6904
6905
6906 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6907 PyObject *resultobj = 0;
6908 wxRect *arg1 = (wxRect *) 0 ;
6909 wxPoint result;
6910 void *argp1 = 0 ;
6911 int res1 = 0 ;
6912 PyObject *swig_obj[1] ;
6913
6914 if (!args) SWIG_fail;
6915 swig_obj[0] = args;
6916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6917 if (!SWIG_IsOK(res1)) {
6918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6919 }
6920 arg1 = reinterpret_cast< wxRect * >(argp1);
6921 {
6922 PyThreadState* __tstate = wxPyBeginAllowThreads();
6923 result = ((wxRect const *)arg1)->GetTopRight();
6924 wxPyEndAllowThreads(__tstate);
6925 if (PyErr_Occurred()) SWIG_fail;
6926 }
6927 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6928 return resultobj;
6929 fail:
6930 return NULL;
6931 }
6932
6933
6934 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6935 PyObject *resultobj = 0;
6936 wxRect *arg1 = (wxRect *) 0 ;
6937 wxPoint *arg2 = 0 ;
6938 void *argp1 = 0 ;
6939 int res1 = 0 ;
6940 wxPoint temp2 ;
6941 PyObject * obj0 = 0 ;
6942 PyObject * obj1 = 0 ;
6943 char * kwnames[] = {
6944 (char *) "self",(char *) "p", NULL
6945 };
6946
6947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6949 if (!SWIG_IsOK(res1)) {
6950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6951 }
6952 arg1 = reinterpret_cast< wxRect * >(argp1);
6953 {
6954 arg2 = &temp2;
6955 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6956 }
6957 {
6958 PyThreadState* __tstate = wxPyBeginAllowThreads();
6959 (arg1)->SetTopRight((wxPoint const &)*arg2);
6960 wxPyEndAllowThreads(__tstate);
6961 if (PyErr_Occurred()) SWIG_fail;
6962 }
6963 resultobj = SWIG_Py_Void();
6964 return resultobj;
6965 fail:
6966 return NULL;
6967 }
6968
6969
6970 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6971 PyObject *resultobj = 0;
6972 wxRect *arg1 = (wxRect *) 0 ;
6973 wxPoint result;
6974 void *argp1 = 0 ;
6975 int res1 = 0 ;
6976 PyObject *swig_obj[1] ;
6977
6978 if (!args) SWIG_fail;
6979 swig_obj[0] = args;
6980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6981 if (!SWIG_IsOK(res1)) {
6982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6983 }
6984 arg1 = reinterpret_cast< wxRect * >(argp1);
6985 {
6986 PyThreadState* __tstate = wxPyBeginAllowThreads();
6987 result = ((wxRect const *)arg1)->GetBottomLeft();
6988 wxPyEndAllowThreads(__tstate);
6989 if (PyErr_Occurred()) SWIG_fail;
6990 }
6991 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6992 return resultobj;
6993 fail:
6994 return NULL;
6995 }
6996
6997
6998 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6999 PyObject *resultobj = 0;
7000 wxRect *arg1 = (wxRect *) 0 ;
7001 wxPoint *arg2 = 0 ;
7002 void *argp1 = 0 ;
7003 int res1 = 0 ;
7004 wxPoint temp2 ;
7005 PyObject * obj0 = 0 ;
7006 PyObject * obj1 = 0 ;
7007 char * kwnames[] = {
7008 (char *) "self",(char *) "p", NULL
7009 };
7010
7011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7013 if (!SWIG_IsOK(res1)) {
7014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7015 }
7016 arg1 = reinterpret_cast< wxRect * >(argp1);
7017 {
7018 arg2 = &temp2;
7019 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7020 }
7021 {
7022 PyThreadState* __tstate = wxPyBeginAllowThreads();
7023 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7024 wxPyEndAllowThreads(__tstate);
7025 if (PyErr_Occurred()) SWIG_fail;
7026 }
7027 resultobj = SWIG_Py_Void();
7028 return resultobj;
7029 fail:
7030 return NULL;
7031 }
7032
7033
7034 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7035 PyObject *resultobj = 0;
7036 wxRect *arg1 = (wxRect *) 0 ;
7037 int result;
7038 void *argp1 = 0 ;
7039 int res1 = 0 ;
7040 PyObject *swig_obj[1] ;
7041
7042 if (!args) SWIG_fail;
7043 swig_obj[0] = args;
7044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7045 if (!SWIG_IsOK(res1)) {
7046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7047 }
7048 arg1 = reinterpret_cast< wxRect * >(argp1);
7049 {
7050 PyThreadState* __tstate = wxPyBeginAllowThreads();
7051 result = (int)((wxRect const *)arg1)->GetLeft();
7052 wxPyEndAllowThreads(__tstate);
7053 if (PyErr_Occurred()) SWIG_fail;
7054 }
7055 resultobj = SWIG_From_int(static_cast< int >(result));
7056 return resultobj;
7057 fail:
7058 return NULL;
7059 }
7060
7061
7062 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7063 PyObject *resultobj = 0;
7064 wxRect *arg1 = (wxRect *) 0 ;
7065 int result;
7066 void *argp1 = 0 ;
7067 int res1 = 0 ;
7068 PyObject *swig_obj[1] ;
7069
7070 if (!args) SWIG_fail;
7071 swig_obj[0] = args;
7072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7073 if (!SWIG_IsOK(res1)) {
7074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7075 }
7076 arg1 = reinterpret_cast< wxRect * >(argp1);
7077 {
7078 PyThreadState* __tstate = wxPyBeginAllowThreads();
7079 result = (int)((wxRect const *)arg1)->GetTop();
7080 wxPyEndAllowThreads(__tstate);
7081 if (PyErr_Occurred()) SWIG_fail;
7082 }
7083 resultobj = SWIG_From_int(static_cast< int >(result));
7084 return resultobj;
7085 fail:
7086 return NULL;
7087 }
7088
7089
7090 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7091 PyObject *resultobj = 0;
7092 wxRect *arg1 = (wxRect *) 0 ;
7093 int result;
7094 void *argp1 = 0 ;
7095 int res1 = 0 ;
7096 PyObject *swig_obj[1] ;
7097
7098 if (!args) SWIG_fail;
7099 swig_obj[0] = args;
7100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7101 if (!SWIG_IsOK(res1)) {
7102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7103 }
7104 arg1 = reinterpret_cast< wxRect * >(argp1);
7105 {
7106 PyThreadState* __tstate = wxPyBeginAllowThreads();
7107 result = (int)((wxRect const *)arg1)->GetBottom();
7108 wxPyEndAllowThreads(__tstate);
7109 if (PyErr_Occurred()) SWIG_fail;
7110 }
7111 resultobj = SWIG_From_int(static_cast< int >(result));
7112 return resultobj;
7113 fail:
7114 return NULL;
7115 }
7116
7117
7118 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7119 PyObject *resultobj = 0;
7120 wxRect *arg1 = (wxRect *) 0 ;
7121 int result;
7122 void *argp1 = 0 ;
7123 int res1 = 0 ;
7124 PyObject *swig_obj[1] ;
7125
7126 if (!args) SWIG_fail;
7127 swig_obj[0] = args;
7128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7129 if (!SWIG_IsOK(res1)) {
7130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7131 }
7132 arg1 = reinterpret_cast< wxRect * >(argp1);
7133 {
7134 PyThreadState* __tstate = wxPyBeginAllowThreads();
7135 result = (int)((wxRect const *)arg1)->GetRight();
7136 wxPyEndAllowThreads(__tstate);
7137 if (PyErr_Occurred()) SWIG_fail;
7138 }
7139 resultobj = SWIG_From_int(static_cast< int >(result));
7140 return resultobj;
7141 fail:
7142 return NULL;
7143 }
7144
7145
7146 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7147 PyObject *resultobj = 0;
7148 wxRect *arg1 = (wxRect *) 0 ;
7149 int arg2 ;
7150 void *argp1 = 0 ;
7151 int res1 = 0 ;
7152 int val2 ;
7153 int ecode2 = 0 ;
7154 PyObject * obj0 = 0 ;
7155 PyObject * obj1 = 0 ;
7156 char * kwnames[] = {
7157 (char *) "self",(char *) "left", NULL
7158 };
7159
7160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7162 if (!SWIG_IsOK(res1)) {
7163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7164 }
7165 arg1 = reinterpret_cast< wxRect * >(argp1);
7166 ecode2 = SWIG_AsVal_int(obj1, &val2);
7167 if (!SWIG_IsOK(ecode2)) {
7168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7169 }
7170 arg2 = static_cast< int >(val2);
7171 {
7172 PyThreadState* __tstate = wxPyBeginAllowThreads();
7173 (arg1)->SetLeft(arg2);
7174 wxPyEndAllowThreads(__tstate);
7175 if (PyErr_Occurred()) SWIG_fail;
7176 }
7177 resultobj = SWIG_Py_Void();
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7185 PyObject *resultobj = 0;
7186 wxRect *arg1 = (wxRect *) 0 ;
7187 int arg2 ;
7188 void *argp1 = 0 ;
7189 int res1 = 0 ;
7190 int val2 ;
7191 int ecode2 = 0 ;
7192 PyObject * obj0 = 0 ;
7193 PyObject * obj1 = 0 ;
7194 char * kwnames[] = {
7195 (char *) "self",(char *) "right", NULL
7196 };
7197
7198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7200 if (!SWIG_IsOK(res1)) {
7201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7202 }
7203 arg1 = reinterpret_cast< wxRect * >(argp1);
7204 ecode2 = SWIG_AsVal_int(obj1, &val2);
7205 if (!SWIG_IsOK(ecode2)) {
7206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7207 }
7208 arg2 = static_cast< int >(val2);
7209 {
7210 PyThreadState* __tstate = wxPyBeginAllowThreads();
7211 (arg1)->SetRight(arg2);
7212 wxPyEndAllowThreads(__tstate);
7213 if (PyErr_Occurred()) SWIG_fail;
7214 }
7215 resultobj = SWIG_Py_Void();
7216 return resultobj;
7217 fail:
7218 return NULL;
7219 }
7220
7221
7222 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7223 PyObject *resultobj = 0;
7224 wxRect *arg1 = (wxRect *) 0 ;
7225 int arg2 ;
7226 void *argp1 = 0 ;
7227 int res1 = 0 ;
7228 int val2 ;
7229 int ecode2 = 0 ;
7230 PyObject * obj0 = 0 ;
7231 PyObject * obj1 = 0 ;
7232 char * kwnames[] = {
7233 (char *) "self",(char *) "top", NULL
7234 };
7235
7236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7238 if (!SWIG_IsOK(res1)) {
7239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7240 }
7241 arg1 = reinterpret_cast< wxRect * >(argp1);
7242 ecode2 = SWIG_AsVal_int(obj1, &val2);
7243 if (!SWIG_IsOK(ecode2)) {
7244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7245 }
7246 arg2 = static_cast< int >(val2);
7247 {
7248 PyThreadState* __tstate = wxPyBeginAllowThreads();
7249 (arg1)->SetTop(arg2);
7250 wxPyEndAllowThreads(__tstate);
7251 if (PyErr_Occurred()) SWIG_fail;
7252 }
7253 resultobj = SWIG_Py_Void();
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7261 PyObject *resultobj = 0;
7262 wxRect *arg1 = (wxRect *) 0 ;
7263 int arg2 ;
7264 void *argp1 = 0 ;
7265 int res1 = 0 ;
7266 int val2 ;
7267 int ecode2 = 0 ;
7268 PyObject * obj0 = 0 ;
7269 PyObject * obj1 = 0 ;
7270 char * kwnames[] = {
7271 (char *) "self",(char *) "bottom", NULL
7272 };
7273
7274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7276 if (!SWIG_IsOK(res1)) {
7277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7278 }
7279 arg1 = reinterpret_cast< wxRect * >(argp1);
7280 ecode2 = SWIG_AsVal_int(obj1, &val2);
7281 if (!SWIG_IsOK(ecode2)) {
7282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7283 }
7284 arg2 = static_cast< int >(val2);
7285 {
7286 PyThreadState* __tstate = wxPyBeginAllowThreads();
7287 (arg1)->SetBottom(arg2);
7288 wxPyEndAllowThreads(__tstate);
7289 if (PyErr_Occurred()) SWIG_fail;
7290 }
7291 resultobj = SWIG_Py_Void();
7292 return resultobj;
7293 fail:
7294 return NULL;
7295 }
7296
7297
7298 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7299 PyObject *resultobj = 0;
7300 wxRect *arg1 = (wxRect *) 0 ;
7301 int arg2 ;
7302 int arg3 ;
7303 wxRect *result = 0 ;
7304 void *argp1 = 0 ;
7305 int res1 = 0 ;
7306 int val2 ;
7307 int ecode2 = 0 ;
7308 int val3 ;
7309 int ecode3 = 0 ;
7310 PyObject * obj0 = 0 ;
7311 PyObject * obj1 = 0 ;
7312 PyObject * obj2 = 0 ;
7313 char * kwnames[] = {
7314 (char *) "self",(char *) "dx",(char *) "dy", NULL
7315 };
7316
7317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7319 if (!SWIG_IsOK(res1)) {
7320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7321 }
7322 arg1 = reinterpret_cast< wxRect * >(argp1);
7323 ecode2 = SWIG_AsVal_int(obj1, &val2);
7324 if (!SWIG_IsOK(ecode2)) {
7325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7326 }
7327 arg2 = static_cast< int >(val2);
7328 ecode3 = SWIG_AsVal_int(obj2, &val3);
7329 if (!SWIG_IsOK(ecode3)) {
7330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7331 }
7332 arg3 = static_cast< int >(val3);
7333 {
7334 PyThreadState* __tstate = wxPyBeginAllowThreads();
7335 {
7336 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7337 result = (wxRect *) &_result_ref;
7338 }
7339 wxPyEndAllowThreads(__tstate);
7340 if (PyErr_Occurred()) SWIG_fail;
7341 }
7342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7343 return resultobj;
7344 fail:
7345 return NULL;
7346 }
7347
7348
7349 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7350 PyObject *resultobj = 0;
7351 wxRect *arg1 = (wxRect *) 0 ;
7352 int arg2 ;
7353 int arg3 ;
7354 wxRect *result = 0 ;
7355 void *argp1 = 0 ;
7356 int res1 = 0 ;
7357 int val2 ;
7358 int ecode2 = 0 ;
7359 int val3 ;
7360 int ecode3 = 0 ;
7361 PyObject * obj0 = 0 ;
7362 PyObject * obj1 = 0 ;
7363 PyObject * obj2 = 0 ;
7364 char * kwnames[] = {
7365 (char *) "self",(char *) "dx",(char *) "dy", NULL
7366 };
7367
7368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7370 if (!SWIG_IsOK(res1)) {
7371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7372 }
7373 arg1 = reinterpret_cast< wxRect * >(argp1);
7374 ecode2 = SWIG_AsVal_int(obj1, &val2);
7375 if (!SWIG_IsOK(ecode2)) {
7376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7377 }
7378 arg2 = static_cast< int >(val2);
7379 ecode3 = SWIG_AsVal_int(obj2, &val3);
7380 if (!SWIG_IsOK(ecode3)) {
7381 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7382 }
7383 arg3 = static_cast< int >(val3);
7384 {
7385 PyThreadState* __tstate = wxPyBeginAllowThreads();
7386 {
7387 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7388 result = (wxRect *) &_result_ref;
7389 }
7390 wxPyEndAllowThreads(__tstate);
7391 if (PyErr_Occurred()) SWIG_fail;
7392 }
7393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7394 return resultobj;
7395 fail:
7396 return NULL;
7397 }
7398
7399
7400 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7401 PyObject *resultobj = 0;
7402 wxRect *arg1 = (wxRect *) 0 ;
7403 int arg2 ;
7404 int arg3 ;
7405 void *argp1 = 0 ;
7406 int res1 = 0 ;
7407 int val2 ;
7408 int ecode2 = 0 ;
7409 int val3 ;
7410 int ecode3 = 0 ;
7411 PyObject * obj0 = 0 ;
7412 PyObject * obj1 = 0 ;
7413 PyObject * obj2 = 0 ;
7414 char * kwnames[] = {
7415 (char *) "self",(char *) "dx",(char *) "dy", NULL
7416 };
7417
7418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7420 if (!SWIG_IsOK(res1)) {
7421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7422 }
7423 arg1 = reinterpret_cast< wxRect * >(argp1);
7424 ecode2 = SWIG_AsVal_int(obj1, &val2);
7425 if (!SWIG_IsOK(ecode2)) {
7426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7427 }
7428 arg2 = static_cast< int >(val2);
7429 ecode3 = SWIG_AsVal_int(obj2, &val3);
7430 if (!SWIG_IsOK(ecode3)) {
7431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7432 }
7433 arg3 = static_cast< int >(val3);
7434 {
7435 PyThreadState* __tstate = wxPyBeginAllowThreads();
7436 (arg1)->Offset(arg2,arg3);
7437 wxPyEndAllowThreads(__tstate);
7438 if (PyErr_Occurred()) SWIG_fail;
7439 }
7440 resultobj = SWIG_Py_Void();
7441 return resultobj;
7442 fail:
7443 return NULL;
7444 }
7445
7446
7447 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7448 PyObject *resultobj = 0;
7449 wxRect *arg1 = (wxRect *) 0 ;
7450 wxPoint *arg2 = 0 ;
7451 void *argp1 = 0 ;
7452 int res1 = 0 ;
7453 wxPoint temp2 ;
7454 PyObject * obj0 = 0 ;
7455 PyObject * obj1 = 0 ;
7456 char * kwnames[] = {
7457 (char *) "self",(char *) "pt", NULL
7458 };
7459
7460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7462 if (!SWIG_IsOK(res1)) {
7463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7464 }
7465 arg1 = reinterpret_cast< wxRect * >(argp1);
7466 {
7467 arg2 = &temp2;
7468 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7469 }
7470 {
7471 PyThreadState* __tstate = wxPyBeginAllowThreads();
7472 (arg1)->Offset((wxPoint const &)*arg2);
7473 wxPyEndAllowThreads(__tstate);
7474 if (PyErr_Occurred()) SWIG_fail;
7475 }
7476 resultobj = SWIG_Py_Void();
7477 return resultobj;
7478 fail:
7479 return NULL;
7480 }
7481
7482
7483 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7484 PyObject *resultobj = 0;
7485 wxRect *arg1 = (wxRect *) 0 ;
7486 wxRect *arg2 = 0 ;
7487 wxRect result;
7488 void *argp1 = 0 ;
7489 int res1 = 0 ;
7490 wxRect temp2 ;
7491 PyObject * obj0 = 0 ;
7492 PyObject * obj1 = 0 ;
7493 char * kwnames[] = {
7494 (char *) "self",(char *) "rect", NULL
7495 };
7496
7497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7499 if (!SWIG_IsOK(res1)) {
7500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7501 }
7502 arg1 = reinterpret_cast< wxRect * >(argp1);
7503 {
7504 arg2 = &temp2;
7505 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7506 }
7507 {
7508 PyThreadState* __tstate = wxPyBeginAllowThreads();
7509 result = (arg1)->Intersect((wxRect const &)*arg2);
7510 wxPyEndAllowThreads(__tstate);
7511 if (PyErr_Occurred()) SWIG_fail;
7512 }
7513 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7514 return resultobj;
7515 fail:
7516 return NULL;
7517 }
7518
7519
7520 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7521 PyObject *resultobj = 0;
7522 wxRect *arg1 = (wxRect *) 0 ;
7523 wxRect *arg2 = 0 ;
7524 wxRect result;
7525 void *argp1 = 0 ;
7526 int res1 = 0 ;
7527 wxRect temp2 ;
7528 PyObject * obj0 = 0 ;
7529 PyObject * obj1 = 0 ;
7530 char * kwnames[] = {
7531 (char *) "self",(char *) "rect", NULL
7532 };
7533
7534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7536 if (!SWIG_IsOK(res1)) {
7537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7538 }
7539 arg1 = reinterpret_cast< wxRect * >(argp1);
7540 {
7541 arg2 = &temp2;
7542 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7543 }
7544 {
7545 PyThreadState* __tstate = wxPyBeginAllowThreads();
7546 result = (arg1)->Union((wxRect const &)*arg2);
7547 wxPyEndAllowThreads(__tstate);
7548 if (PyErr_Occurred()) SWIG_fail;
7549 }
7550 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7551 return resultobj;
7552 fail:
7553 return NULL;
7554 }
7555
7556
7557 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7558 PyObject *resultobj = 0;
7559 wxRect *arg1 = (wxRect *) 0 ;
7560 wxRect *arg2 = 0 ;
7561 wxRect result;
7562 void *argp1 = 0 ;
7563 int res1 = 0 ;
7564 wxRect temp2 ;
7565 PyObject * obj0 = 0 ;
7566 PyObject * obj1 = 0 ;
7567 char * kwnames[] = {
7568 (char *) "self",(char *) "rect", NULL
7569 };
7570
7571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7573 if (!SWIG_IsOK(res1)) {
7574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7575 }
7576 arg1 = reinterpret_cast< wxRect * >(argp1);
7577 {
7578 arg2 = &temp2;
7579 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7580 }
7581 {
7582 PyThreadState* __tstate = wxPyBeginAllowThreads();
7583 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7584 wxPyEndAllowThreads(__tstate);
7585 if (PyErr_Occurred()) SWIG_fail;
7586 }
7587 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7588 return resultobj;
7589 fail:
7590 return NULL;
7591 }
7592
7593
7594 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7595 PyObject *resultobj = 0;
7596 wxRect *arg1 = (wxRect *) 0 ;
7597 wxRect *arg2 = 0 ;
7598 wxRect *result = 0 ;
7599 void *argp1 = 0 ;
7600 int res1 = 0 ;
7601 wxRect temp2 ;
7602 PyObject * obj0 = 0 ;
7603 PyObject * obj1 = 0 ;
7604 char * kwnames[] = {
7605 (char *) "self",(char *) "rect", NULL
7606 };
7607
7608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7610 if (!SWIG_IsOK(res1)) {
7611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7612 }
7613 arg1 = reinterpret_cast< wxRect * >(argp1);
7614 {
7615 arg2 = &temp2;
7616 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7617 }
7618 {
7619 PyThreadState* __tstate = wxPyBeginAllowThreads();
7620 {
7621 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7622 result = (wxRect *) &_result_ref;
7623 }
7624 wxPyEndAllowThreads(__tstate);
7625 if (PyErr_Occurred()) SWIG_fail;
7626 }
7627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7628 return resultobj;
7629 fail:
7630 return NULL;
7631 }
7632
7633
7634 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7635 PyObject *resultobj = 0;
7636 wxRect *arg1 = (wxRect *) 0 ;
7637 PyObject *arg2 = (PyObject *) 0 ;
7638 bool result;
7639 void *argp1 = 0 ;
7640 int res1 = 0 ;
7641 PyObject * obj0 = 0 ;
7642 PyObject * obj1 = 0 ;
7643 char * kwnames[] = {
7644 (char *) "self",(char *) "other", NULL
7645 };
7646
7647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7649 if (!SWIG_IsOK(res1)) {
7650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7651 }
7652 arg1 = reinterpret_cast< wxRect * >(argp1);
7653 arg2 = obj1;
7654 {
7655 result = (bool)wxRect___eq__(arg1,arg2);
7656 if (PyErr_Occurred()) SWIG_fail;
7657 }
7658 {
7659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7660 }
7661 return resultobj;
7662 fail:
7663 return NULL;
7664 }
7665
7666
7667 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7668 PyObject *resultobj = 0;
7669 wxRect *arg1 = (wxRect *) 0 ;
7670 PyObject *arg2 = (PyObject *) 0 ;
7671 bool result;
7672 void *argp1 = 0 ;
7673 int res1 = 0 ;
7674 PyObject * obj0 = 0 ;
7675 PyObject * obj1 = 0 ;
7676 char * kwnames[] = {
7677 (char *) "self",(char *) "other", NULL
7678 };
7679
7680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7682 if (!SWIG_IsOK(res1)) {
7683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7684 }
7685 arg1 = reinterpret_cast< wxRect * >(argp1);
7686 arg2 = obj1;
7687 {
7688 result = (bool)wxRect___ne__(arg1,arg2);
7689 if (PyErr_Occurred()) SWIG_fail;
7690 }
7691 {
7692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7693 }
7694 return resultobj;
7695 fail:
7696 return NULL;
7697 }
7698
7699
7700 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7701 PyObject *resultobj = 0;
7702 wxRect *arg1 = (wxRect *) 0 ;
7703 int arg2 ;
7704 int arg3 ;
7705 bool result;
7706 void *argp1 = 0 ;
7707 int res1 = 0 ;
7708 int val2 ;
7709 int ecode2 = 0 ;
7710 int val3 ;
7711 int ecode3 = 0 ;
7712 PyObject * obj0 = 0 ;
7713 PyObject * obj1 = 0 ;
7714 PyObject * obj2 = 0 ;
7715 char * kwnames[] = {
7716 (char *) "self",(char *) "x",(char *) "y", NULL
7717 };
7718
7719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7723 }
7724 arg1 = reinterpret_cast< wxRect * >(argp1);
7725 ecode2 = SWIG_AsVal_int(obj1, &val2);
7726 if (!SWIG_IsOK(ecode2)) {
7727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7728 }
7729 arg2 = static_cast< int >(val2);
7730 ecode3 = SWIG_AsVal_int(obj2, &val3);
7731 if (!SWIG_IsOK(ecode3)) {
7732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7733 }
7734 arg3 = static_cast< int >(val3);
7735 {
7736 PyThreadState* __tstate = wxPyBeginAllowThreads();
7737 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7738 wxPyEndAllowThreads(__tstate);
7739 if (PyErr_Occurred()) SWIG_fail;
7740 }
7741 {
7742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7743 }
7744 return resultobj;
7745 fail:
7746 return NULL;
7747 }
7748
7749
7750 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7751 PyObject *resultobj = 0;
7752 wxRect *arg1 = (wxRect *) 0 ;
7753 wxPoint *arg2 = 0 ;
7754 bool result;
7755 void *argp1 = 0 ;
7756 int res1 = 0 ;
7757 wxPoint temp2 ;
7758 PyObject * obj0 = 0 ;
7759 PyObject * obj1 = 0 ;
7760 char * kwnames[] = {
7761 (char *) "self",(char *) "pt", NULL
7762 };
7763
7764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7766 if (!SWIG_IsOK(res1)) {
7767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7768 }
7769 arg1 = reinterpret_cast< wxRect * >(argp1);
7770 {
7771 arg2 = &temp2;
7772 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7773 }
7774 {
7775 PyThreadState* __tstate = wxPyBeginAllowThreads();
7776 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7777 wxPyEndAllowThreads(__tstate);
7778 if (PyErr_Occurred()) SWIG_fail;
7779 }
7780 {
7781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7782 }
7783 return resultobj;
7784 fail:
7785 return NULL;
7786 }
7787
7788
7789 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7790 PyObject *resultobj = 0;
7791 wxRect *arg1 = (wxRect *) 0 ;
7792 wxRect *arg2 = 0 ;
7793 bool result;
7794 void *argp1 = 0 ;
7795 int res1 = 0 ;
7796 wxRect temp2 ;
7797 PyObject * obj0 = 0 ;
7798 PyObject * obj1 = 0 ;
7799 char * kwnames[] = {
7800 (char *) "self",(char *) "rect", NULL
7801 };
7802
7803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7805 if (!SWIG_IsOK(res1)) {
7806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7807 }
7808 arg1 = reinterpret_cast< wxRect * >(argp1);
7809 {
7810 arg2 = &temp2;
7811 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7812 }
7813 {
7814 PyThreadState* __tstate = wxPyBeginAllowThreads();
7815 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7816 wxPyEndAllowThreads(__tstate);
7817 if (PyErr_Occurred()) SWIG_fail;
7818 }
7819 {
7820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7821 }
7822 return resultobj;
7823 fail:
7824 return NULL;
7825 }
7826
7827
7828 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7829 PyObject *resultobj = 0;
7830 wxRect *arg1 = (wxRect *) 0 ;
7831 wxRect *arg2 = 0 ;
7832 bool result;
7833 void *argp1 = 0 ;
7834 int res1 = 0 ;
7835 wxRect temp2 ;
7836 PyObject * obj0 = 0 ;
7837 PyObject * obj1 = 0 ;
7838 char * kwnames[] = {
7839 (char *) "self",(char *) "rect", NULL
7840 };
7841
7842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7844 if (!SWIG_IsOK(res1)) {
7845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7846 }
7847 arg1 = reinterpret_cast< wxRect * >(argp1);
7848 {
7849 arg2 = &temp2;
7850 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7851 }
7852 {
7853 PyThreadState* __tstate = wxPyBeginAllowThreads();
7854 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7855 wxPyEndAllowThreads(__tstate);
7856 if (PyErr_Occurred()) SWIG_fail;
7857 }
7858 {
7859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7860 }
7861 return resultobj;
7862 fail:
7863 return NULL;
7864 }
7865
7866
7867 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7868 PyObject *resultobj = 0;
7869 wxRect *arg1 = (wxRect *) 0 ;
7870 wxRect *arg2 = 0 ;
7871 int arg3 = (int) wxBOTH ;
7872 wxRect result;
7873 void *argp1 = 0 ;
7874 int res1 = 0 ;
7875 wxRect temp2 ;
7876 int val3 ;
7877 int ecode3 = 0 ;
7878 PyObject * obj0 = 0 ;
7879 PyObject * obj1 = 0 ;
7880 PyObject * obj2 = 0 ;
7881 char * kwnames[] = {
7882 (char *) "self",(char *) "r",(char *) "dir", NULL
7883 };
7884
7885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7887 if (!SWIG_IsOK(res1)) {
7888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7889 }
7890 arg1 = reinterpret_cast< wxRect * >(argp1);
7891 {
7892 arg2 = &temp2;
7893 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7894 }
7895 if (obj2) {
7896 ecode3 = SWIG_AsVal_int(obj2, &val3);
7897 if (!SWIG_IsOK(ecode3)) {
7898 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7899 }
7900 arg3 = static_cast< int >(val3);
7901 }
7902 {
7903 PyThreadState* __tstate = wxPyBeginAllowThreads();
7904 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7905 wxPyEndAllowThreads(__tstate);
7906 if (PyErr_Occurred()) SWIG_fail;
7907 }
7908 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7909 return resultobj;
7910 fail:
7911 return NULL;
7912 }
7913
7914
7915 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7916 PyObject *resultobj = 0;
7917 wxRect *arg1 = (wxRect *) 0 ;
7918 int arg2 ;
7919 void *argp1 = 0 ;
7920 int res1 = 0 ;
7921 int val2 ;
7922 int ecode2 = 0 ;
7923 PyObject *swig_obj[2] ;
7924
7925 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7927 if (!SWIG_IsOK(res1)) {
7928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7929 }
7930 arg1 = reinterpret_cast< wxRect * >(argp1);
7931 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7932 if (!SWIG_IsOK(ecode2)) {
7933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7934 }
7935 arg2 = static_cast< int >(val2);
7936 if (arg1) (arg1)->x = arg2;
7937
7938 resultobj = SWIG_Py_Void();
7939 return resultobj;
7940 fail:
7941 return NULL;
7942 }
7943
7944
7945 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7946 PyObject *resultobj = 0;
7947 wxRect *arg1 = (wxRect *) 0 ;
7948 int result;
7949 void *argp1 = 0 ;
7950 int res1 = 0 ;
7951 PyObject *swig_obj[1] ;
7952
7953 if (!args) SWIG_fail;
7954 swig_obj[0] = args;
7955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7956 if (!SWIG_IsOK(res1)) {
7957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7958 }
7959 arg1 = reinterpret_cast< wxRect * >(argp1);
7960 result = (int) ((arg1)->x);
7961 resultobj = SWIG_From_int(static_cast< int >(result));
7962 return resultobj;
7963 fail:
7964 return NULL;
7965 }
7966
7967
7968 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7969 PyObject *resultobj = 0;
7970 wxRect *arg1 = (wxRect *) 0 ;
7971 int arg2 ;
7972 void *argp1 = 0 ;
7973 int res1 = 0 ;
7974 int val2 ;
7975 int ecode2 = 0 ;
7976 PyObject *swig_obj[2] ;
7977
7978 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7980 if (!SWIG_IsOK(res1)) {
7981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7982 }
7983 arg1 = reinterpret_cast< wxRect * >(argp1);
7984 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7985 if (!SWIG_IsOK(ecode2)) {
7986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7987 }
7988 arg2 = static_cast< int >(val2);
7989 if (arg1) (arg1)->y = arg2;
7990
7991 resultobj = SWIG_Py_Void();
7992 return resultobj;
7993 fail:
7994 return NULL;
7995 }
7996
7997
7998 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7999 PyObject *resultobj = 0;
8000 wxRect *arg1 = (wxRect *) 0 ;
8001 int result;
8002 void *argp1 = 0 ;
8003 int res1 = 0 ;
8004 PyObject *swig_obj[1] ;
8005
8006 if (!args) SWIG_fail;
8007 swig_obj[0] = args;
8008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8009 if (!SWIG_IsOK(res1)) {
8010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8011 }
8012 arg1 = reinterpret_cast< wxRect * >(argp1);
8013 result = (int) ((arg1)->y);
8014 resultobj = SWIG_From_int(static_cast< int >(result));
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8022 PyObject *resultobj = 0;
8023 wxRect *arg1 = (wxRect *) 0 ;
8024 int arg2 ;
8025 void *argp1 = 0 ;
8026 int res1 = 0 ;
8027 int val2 ;
8028 int ecode2 = 0 ;
8029 PyObject *swig_obj[2] ;
8030
8031 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8033 if (!SWIG_IsOK(res1)) {
8034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8035 }
8036 arg1 = reinterpret_cast< wxRect * >(argp1);
8037 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8038 if (!SWIG_IsOK(ecode2)) {
8039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8040 }
8041 arg2 = static_cast< int >(val2);
8042 if (arg1) (arg1)->width = arg2;
8043
8044 resultobj = SWIG_Py_Void();
8045 return resultobj;
8046 fail:
8047 return NULL;
8048 }
8049
8050
8051 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8052 PyObject *resultobj = 0;
8053 wxRect *arg1 = (wxRect *) 0 ;
8054 int result;
8055 void *argp1 = 0 ;
8056 int res1 = 0 ;
8057 PyObject *swig_obj[1] ;
8058
8059 if (!args) SWIG_fail;
8060 swig_obj[0] = args;
8061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8062 if (!SWIG_IsOK(res1)) {
8063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8064 }
8065 arg1 = reinterpret_cast< wxRect * >(argp1);
8066 result = (int) ((arg1)->width);
8067 resultobj = SWIG_From_int(static_cast< int >(result));
8068 return resultobj;
8069 fail:
8070 return NULL;
8071 }
8072
8073
8074 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8075 PyObject *resultobj = 0;
8076 wxRect *arg1 = (wxRect *) 0 ;
8077 int arg2 ;
8078 void *argp1 = 0 ;
8079 int res1 = 0 ;
8080 int val2 ;
8081 int ecode2 = 0 ;
8082 PyObject *swig_obj[2] ;
8083
8084 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8086 if (!SWIG_IsOK(res1)) {
8087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8088 }
8089 arg1 = reinterpret_cast< wxRect * >(argp1);
8090 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8091 if (!SWIG_IsOK(ecode2)) {
8092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8093 }
8094 arg2 = static_cast< int >(val2);
8095 if (arg1) (arg1)->height = arg2;
8096
8097 resultobj = SWIG_Py_Void();
8098 return resultobj;
8099 fail:
8100 return NULL;
8101 }
8102
8103
8104 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8105 PyObject *resultobj = 0;
8106 wxRect *arg1 = (wxRect *) 0 ;
8107 int result;
8108 void *argp1 = 0 ;
8109 int res1 = 0 ;
8110 PyObject *swig_obj[1] ;
8111
8112 if (!args) SWIG_fail;
8113 swig_obj[0] = args;
8114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8115 if (!SWIG_IsOK(res1)) {
8116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8117 }
8118 arg1 = reinterpret_cast< wxRect * >(argp1);
8119 result = (int) ((arg1)->height);
8120 resultobj = SWIG_From_int(static_cast< int >(result));
8121 return resultobj;
8122 fail:
8123 return NULL;
8124 }
8125
8126
8127 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8128 PyObject *resultobj = 0;
8129 wxRect *arg1 = (wxRect *) 0 ;
8130 int arg2 = (int) 0 ;
8131 int arg3 = (int) 0 ;
8132 int arg4 = (int) 0 ;
8133 int arg5 = (int) 0 ;
8134 void *argp1 = 0 ;
8135 int res1 = 0 ;
8136 int val2 ;
8137 int ecode2 = 0 ;
8138 int val3 ;
8139 int ecode3 = 0 ;
8140 int val4 ;
8141 int ecode4 = 0 ;
8142 int val5 ;
8143 int ecode5 = 0 ;
8144 PyObject * obj0 = 0 ;
8145 PyObject * obj1 = 0 ;
8146 PyObject * obj2 = 0 ;
8147 PyObject * obj3 = 0 ;
8148 PyObject * obj4 = 0 ;
8149 char * kwnames[] = {
8150 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8151 };
8152
8153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8155 if (!SWIG_IsOK(res1)) {
8156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8157 }
8158 arg1 = reinterpret_cast< wxRect * >(argp1);
8159 if (obj1) {
8160 ecode2 = SWIG_AsVal_int(obj1, &val2);
8161 if (!SWIG_IsOK(ecode2)) {
8162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8163 }
8164 arg2 = static_cast< int >(val2);
8165 }
8166 if (obj2) {
8167 ecode3 = SWIG_AsVal_int(obj2, &val3);
8168 if (!SWIG_IsOK(ecode3)) {
8169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8170 }
8171 arg3 = static_cast< int >(val3);
8172 }
8173 if (obj3) {
8174 ecode4 = SWIG_AsVal_int(obj3, &val4);
8175 if (!SWIG_IsOK(ecode4)) {
8176 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8177 }
8178 arg4 = static_cast< int >(val4);
8179 }
8180 if (obj4) {
8181 ecode5 = SWIG_AsVal_int(obj4, &val5);
8182 if (!SWIG_IsOK(ecode5)) {
8183 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8184 }
8185 arg5 = static_cast< int >(val5);
8186 }
8187 {
8188 PyThreadState* __tstate = wxPyBeginAllowThreads();
8189 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8190 wxPyEndAllowThreads(__tstate);
8191 if (PyErr_Occurred()) SWIG_fail;
8192 }
8193 resultobj = SWIG_Py_Void();
8194 return resultobj;
8195 fail:
8196 return NULL;
8197 }
8198
8199
8200 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8201 PyObject *resultobj = 0;
8202 wxRect *arg1 = (wxRect *) 0 ;
8203 PyObject *result = 0 ;
8204 void *argp1 = 0 ;
8205 int res1 = 0 ;
8206 PyObject *swig_obj[1] ;
8207
8208 if (!args) SWIG_fail;
8209 swig_obj[0] = args;
8210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8211 if (!SWIG_IsOK(res1)) {
8212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8213 }
8214 arg1 = reinterpret_cast< wxRect * >(argp1);
8215 {
8216 PyThreadState* __tstate = wxPyBeginAllowThreads();
8217 result = (PyObject *)wxRect_Get(arg1);
8218 wxPyEndAllowThreads(__tstate);
8219 if (PyErr_Occurred()) SWIG_fail;
8220 }
8221 resultobj = result;
8222 return resultobj;
8223 fail:
8224 return NULL;
8225 }
8226
8227
8228 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8229 PyObject *obj;
8230 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8231 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8232 return SWIG_Py_Void();
8233 }
8234
8235 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8236 return SWIG_Python_InitShadowInstance(args);
8237 }
8238
8239 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8240 PyObject *resultobj = 0;
8241 wxRect *arg1 = (wxRect *) 0 ;
8242 wxRect *arg2 = (wxRect *) 0 ;
8243 PyObject *result = 0 ;
8244 void *argp1 = 0 ;
8245 int res1 = 0 ;
8246 void *argp2 = 0 ;
8247 int res2 = 0 ;
8248 PyObject * obj0 = 0 ;
8249 PyObject * obj1 = 0 ;
8250 char * kwnames[] = {
8251 (char *) "r1",(char *) "r2", NULL
8252 };
8253
8254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8256 if (!SWIG_IsOK(res1)) {
8257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8258 }
8259 arg1 = reinterpret_cast< wxRect * >(argp1);
8260 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8261 if (!SWIG_IsOK(res2)) {
8262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8263 }
8264 arg2 = reinterpret_cast< wxRect * >(argp2);
8265 {
8266 if (!wxPyCheckForApp()) SWIG_fail;
8267 PyThreadState* __tstate = wxPyBeginAllowThreads();
8268 result = (PyObject *)wxIntersectRect(arg1,arg2);
8269 wxPyEndAllowThreads(__tstate);
8270 if (PyErr_Occurred()) SWIG_fail;
8271 }
8272 resultobj = result;
8273 return resultobj;
8274 fail:
8275 return NULL;
8276 }
8277
8278
8279 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8280 PyObject *resultobj = 0;
8281 double arg1 = (double) 0.0 ;
8282 double arg2 = (double) 0.0 ;
8283 wxPoint2D *result = 0 ;
8284 double val1 ;
8285 int ecode1 = 0 ;
8286 double val2 ;
8287 int ecode2 = 0 ;
8288 PyObject * obj0 = 0 ;
8289 PyObject * obj1 = 0 ;
8290 char * kwnames[] = {
8291 (char *) "x",(char *) "y", NULL
8292 };
8293
8294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8295 if (obj0) {
8296 ecode1 = SWIG_AsVal_double(obj0, &val1);
8297 if (!SWIG_IsOK(ecode1)) {
8298 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8299 }
8300 arg1 = static_cast< double >(val1);
8301 }
8302 if (obj1) {
8303 ecode2 = SWIG_AsVal_double(obj1, &val2);
8304 if (!SWIG_IsOK(ecode2)) {
8305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8306 }
8307 arg2 = static_cast< double >(val2);
8308 }
8309 {
8310 PyThreadState* __tstate = wxPyBeginAllowThreads();
8311 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8312 wxPyEndAllowThreads(__tstate);
8313 if (PyErr_Occurred()) SWIG_fail;
8314 }
8315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8323 PyObject *resultobj = 0;
8324 wxPoint2D *arg1 = 0 ;
8325 wxPoint2D *result = 0 ;
8326 wxPoint2D temp1 ;
8327 PyObject * obj0 = 0 ;
8328 char * kwnames[] = {
8329 (char *) "pt", NULL
8330 };
8331
8332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8333 {
8334 arg1 = &temp1;
8335 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8336 }
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8340 wxPyEndAllowThreads(__tstate);
8341 if (PyErr_Occurred()) SWIG_fail;
8342 }
8343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8344 return resultobj;
8345 fail:
8346 return NULL;
8347 }
8348
8349
8350 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8351 PyObject *resultobj = 0;
8352 wxPoint *arg1 = 0 ;
8353 wxPoint2D *result = 0 ;
8354 wxPoint temp1 ;
8355 PyObject * obj0 = 0 ;
8356 char * kwnames[] = {
8357 (char *) "pt", NULL
8358 };
8359
8360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8361 {
8362 arg1 = &temp1;
8363 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8364 }
8365 {
8366 PyThreadState* __tstate = wxPyBeginAllowThreads();
8367 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8368 wxPyEndAllowThreads(__tstate);
8369 if (PyErr_Occurred()) SWIG_fail;
8370 }
8371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8372 return resultobj;
8373 fail:
8374 return NULL;
8375 }
8376
8377
8378 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8379 PyObject *resultobj = 0;
8380 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8381 int *arg2 = (int *) 0 ;
8382 int *arg3 = (int *) 0 ;
8383 void *argp1 = 0 ;
8384 int res1 = 0 ;
8385 int temp2 ;
8386 int res2 = SWIG_TMPOBJ ;
8387 int temp3 ;
8388 int res3 = SWIG_TMPOBJ ;
8389 PyObject *swig_obj[1] ;
8390
8391 arg2 = &temp2;
8392 arg3 = &temp3;
8393 if (!args) SWIG_fail;
8394 swig_obj[0] = args;
8395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8396 if (!SWIG_IsOK(res1)) {
8397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8398 }
8399 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8400 {
8401 PyThreadState* __tstate = wxPyBeginAllowThreads();
8402 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8403 wxPyEndAllowThreads(__tstate);
8404 if (PyErr_Occurred()) SWIG_fail;
8405 }
8406 resultobj = SWIG_Py_Void();
8407 if (SWIG_IsTmpObj(res2)) {
8408 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8409 } else {
8410 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8411 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8412 }
8413 if (SWIG_IsTmpObj(res3)) {
8414 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8415 } else {
8416 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8417 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8418 }
8419 return resultobj;
8420 fail:
8421 return NULL;
8422 }
8423
8424
8425 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8426 PyObject *resultobj = 0;
8427 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8428 int *arg2 = (int *) 0 ;
8429 int *arg3 = (int *) 0 ;
8430 void *argp1 = 0 ;
8431 int res1 = 0 ;
8432 int temp2 ;
8433 int res2 = SWIG_TMPOBJ ;
8434 int temp3 ;
8435 int res3 = SWIG_TMPOBJ ;
8436 PyObject *swig_obj[1] ;
8437
8438 arg2 = &temp2;
8439 arg3 = &temp3;
8440 if (!args) SWIG_fail;
8441 swig_obj[0] = args;
8442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8443 if (!SWIG_IsOK(res1)) {
8444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8445 }
8446 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8447 {
8448 PyThreadState* __tstate = wxPyBeginAllowThreads();
8449 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8450 wxPyEndAllowThreads(__tstate);
8451 if (PyErr_Occurred()) SWIG_fail;
8452 }
8453 resultobj = SWIG_Py_Void();
8454 if (SWIG_IsTmpObj(res2)) {
8455 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8456 } else {
8457 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8458 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8459 }
8460 if (SWIG_IsTmpObj(res3)) {
8461 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8462 } else {
8463 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8465 }
8466 return resultobj;
8467 fail:
8468 return NULL;
8469 }
8470
8471
8472 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8473 PyObject *resultobj = 0;
8474 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8475 double result;
8476 void *argp1 = 0 ;
8477 int res1 = 0 ;
8478 PyObject *swig_obj[1] ;
8479
8480 if (!args) SWIG_fail;
8481 swig_obj[0] = args;
8482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8483 if (!SWIG_IsOK(res1)) {
8484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8485 }
8486 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8487 {
8488 PyThreadState* __tstate = wxPyBeginAllowThreads();
8489 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8490 wxPyEndAllowThreads(__tstate);
8491 if (PyErr_Occurred()) SWIG_fail;
8492 }
8493 resultobj = SWIG_From_double(static_cast< double >(result));
8494 return resultobj;
8495 fail:
8496 return NULL;
8497 }
8498
8499
8500 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8501 PyObject *resultobj = 0;
8502 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8503 double result;
8504 void *argp1 = 0 ;
8505 int res1 = 0 ;
8506 PyObject *swig_obj[1] ;
8507
8508 if (!args) SWIG_fail;
8509 swig_obj[0] = args;
8510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8511 if (!SWIG_IsOK(res1)) {
8512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8513 }
8514 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8515 {
8516 PyThreadState* __tstate = wxPyBeginAllowThreads();
8517 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8518 wxPyEndAllowThreads(__tstate);
8519 if (PyErr_Occurred()) SWIG_fail;
8520 }
8521 resultobj = SWIG_From_double(static_cast< double >(result));
8522 return resultobj;
8523 fail:
8524 return NULL;
8525 }
8526
8527
8528 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8529 PyObject *resultobj = 0;
8530 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8531 double arg2 ;
8532 void *argp1 = 0 ;
8533 int res1 = 0 ;
8534 double val2 ;
8535 int ecode2 = 0 ;
8536 PyObject * obj0 = 0 ;
8537 PyObject * obj1 = 0 ;
8538 char * kwnames[] = {
8539 (char *) "self",(char *) "length", NULL
8540 };
8541
8542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8544 if (!SWIG_IsOK(res1)) {
8545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8546 }
8547 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8548 ecode2 = SWIG_AsVal_double(obj1, &val2);
8549 if (!SWIG_IsOK(ecode2)) {
8550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8551 }
8552 arg2 = static_cast< double >(val2);
8553 {
8554 PyThreadState* __tstate = wxPyBeginAllowThreads();
8555 (arg1)->SetVectorLength(arg2);
8556 wxPyEndAllowThreads(__tstate);
8557 if (PyErr_Occurred()) SWIG_fail;
8558 }
8559 resultobj = SWIG_Py_Void();
8560 return resultobj;
8561 fail:
8562 return NULL;
8563 }
8564
8565
8566 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8567 PyObject *resultobj = 0;
8568 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8569 double arg2 ;
8570 void *argp1 = 0 ;
8571 int res1 = 0 ;
8572 double val2 ;
8573 int ecode2 = 0 ;
8574 PyObject * obj0 = 0 ;
8575 PyObject * obj1 = 0 ;
8576 char * kwnames[] = {
8577 (char *) "self",(char *) "degrees", NULL
8578 };
8579
8580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8582 if (!SWIG_IsOK(res1)) {
8583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8584 }
8585 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8586 ecode2 = SWIG_AsVal_double(obj1, &val2);
8587 if (!SWIG_IsOK(ecode2)) {
8588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8589 }
8590 arg2 = static_cast< double >(val2);
8591 {
8592 PyThreadState* __tstate = wxPyBeginAllowThreads();
8593 (arg1)->SetVectorAngle(arg2);
8594 wxPyEndAllowThreads(__tstate);
8595 if (PyErr_Occurred()) SWIG_fail;
8596 }
8597 resultobj = SWIG_Py_Void();
8598 return resultobj;
8599 fail:
8600 return NULL;
8601 }
8602
8603
8604 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8605 PyObject *resultobj = 0;
8606 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8607 wxPoint2D *arg2 = 0 ;
8608 double result;
8609 void *argp1 = 0 ;
8610 int res1 = 0 ;
8611 wxPoint2D temp2 ;
8612 PyObject * obj0 = 0 ;
8613 PyObject * obj1 = 0 ;
8614 char * kwnames[] = {
8615 (char *) "self",(char *) "pt", NULL
8616 };
8617
8618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8620 if (!SWIG_IsOK(res1)) {
8621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8622 }
8623 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8624 {
8625 arg2 = &temp2;
8626 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8627 }
8628 {
8629 PyThreadState* __tstate = wxPyBeginAllowThreads();
8630 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8631 wxPyEndAllowThreads(__tstate);
8632 if (PyErr_Occurred()) SWIG_fail;
8633 }
8634 resultobj = SWIG_From_double(static_cast< double >(result));
8635 return resultobj;
8636 fail:
8637 return NULL;
8638 }
8639
8640
8641 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8642 PyObject *resultobj = 0;
8643 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8644 wxPoint2D *arg2 = 0 ;
8645 double result;
8646 void *argp1 = 0 ;
8647 int res1 = 0 ;
8648 wxPoint2D temp2 ;
8649 PyObject * obj0 = 0 ;
8650 PyObject * obj1 = 0 ;
8651 char * kwnames[] = {
8652 (char *) "self",(char *) "pt", NULL
8653 };
8654
8655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8657 if (!SWIG_IsOK(res1)) {
8658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8659 }
8660 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8661 {
8662 arg2 = &temp2;
8663 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8664 }
8665 {
8666 PyThreadState* __tstate = wxPyBeginAllowThreads();
8667 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8668 wxPyEndAllowThreads(__tstate);
8669 if (PyErr_Occurred()) SWIG_fail;
8670 }
8671 resultobj = SWIG_From_double(static_cast< double >(result));
8672 return resultobj;
8673 fail:
8674 return NULL;
8675 }
8676
8677
8678 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8679 PyObject *resultobj = 0;
8680 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8681 wxPoint2D *arg2 = 0 ;
8682 double result;
8683 void *argp1 = 0 ;
8684 int res1 = 0 ;
8685 wxPoint2D temp2 ;
8686 PyObject * obj0 = 0 ;
8687 PyObject * obj1 = 0 ;
8688 char * kwnames[] = {
8689 (char *) "self",(char *) "vec", NULL
8690 };
8691
8692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8694 if (!SWIG_IsOK(res1)) {
8695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8696 }
8697 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8698 {
8699 arg2 = &temp2;
8700 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8701 }
8702 {
8703 PyThreadState* __tstate = wxPyBeginAllowThreads();
8704 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8705 wxPyEndAllowThreads(__tstate);
8706 if (PyErr_Occurred()) SWIG_fail;
8707 }
8708 resultobj = SWIG_From_double(static_cast< double >(result));
8709 return resultobj;
8710 fail:
8711 return NULL;
8712 }
8713
8714
8715 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8716 PyObject *resultobj = 0;
8717 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8718 wxPoint2D *arg2 = 0 ;
8719 double result;
8720 void *argp1 = 0 ;
8721 int res1 = 0 ;
8722 wxPoint2D temp2 ;
8723 PyObject * obj0 = 0 ;
8724 PyObject * obj1 = 0 ;
8725 char * kwnames[] = {
8726 (char *) "self",(char *) "vec", NULL
8727 };
8728
8729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8731 if (!SWIG_IsOK(res1)) {
8732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8733 }
8734 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8735 {
8736 arg2 = &temp2;
8737 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8738 }
8739 {
8740 PyThreadState* __tstate = wxPyBeginAllowThreads();
8741 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8742 wxPyEndAllowThreads(__tstate);
8743 if (PyErr_Occurred()) SWIG_fail;
8744 }
8745 resultobj = SWIG_From_double(static_cast< double >(result));
8746 return resultobj;
8747 fail:
8748 return NULL;
8749 }
8750
8751
8752 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8753 PyObject *resultobj = 0;
8754 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8755 wxPoint2D result;
8756 void *argp1 = 0 ;
8757 int res1 = 0 ;
8758 PyObject *swig_obj[1] ;
8759
8760 if (!args) SWIG_fail;
8761 swig_obj[0] = args;
8762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8763 if (!SWIG_IsOK(res1)) {
8764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8765 }
8766 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8767 {
8768 PyThreadState* __tstate = wxPyBeginAllowThreads();
8769 result = (arg1)->operator -();
8770 wxPyEndAllowThreads(__tstate);
8771 if (PyErr_Occurred()) SWIG_fail;
8772 }
8773 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8774 return resultobj;
8775 fail:
8776 return NULL;
8777 }
8778
8779
8780 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8781 PyObject *resultobj = 0;
8782 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8783 wxPoint2D *arg2 = 0 ;
8784 wxPoint2D *result = 0 ;
8785 void *argp1 = 0 ;
8786 int res1 = 0 ;
8787 wxPoint2D temp2 ;
8788 PyObject * obj0 = 0 ;
8789 PyObject * obj1 = 0 ;
8790 char * kwnames[] = {
8791 (char *) "self",(char *) "pt", NULL
8792 };
8793
8794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8796 if (!SWIG_IsOK(res1)) {
8797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8798 }
8799 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8800 {
8801 arg2 = &temp2;
8802 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8803 }
8804 {
8805 PyThreadState* __tstate = wxPyBeginAllowThreads();
8806 {
8807 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8808 result = (wxPoint2D *) &_result_ref;
8809 }
8810 wxPyEndAllowThreads(__tstate);
8811 if (PyErr_Occurred()) SWIG_fail;
8812 }
8813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8814 return resultobj;
8815 fail:
8816 return NULL;
8817 }
8818
8819
8820 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8821 PyObject *resultobj = 0;
8822 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8823 wxPoint2D *arg2 = 0 ;
8824 wxPoint2D *result = 0 ;
8825 void *argp1 = 0 ;
8826 int res1 = 0 ;
8827 wxPoint2D temp2 ;
8828 PyObject * obj0 = 0 ;
8829 PyObject * obj1 = 0 ;
8830 char * kwnames[] = {
8831 (char *) "self",(char *) "pt", NULL
8832 };
8833
8834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8836 if (!SWIG_IsOK(res1)) {
8837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8838 }
8839 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8840 {
8841 arg2 = &temp2;
8842 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8843 }
8844 {
8845 PyThreadState* __tstate = wxPyBeginAllowThreads();
8846 {
8847 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8848 result = (wxPoint2D *) &_result_ref;
8849 }
8850 wxPyEndAllowThreads(__tstate);
8851 if (PyErr_Occurred()) SWIG_fail;
8852 }
8853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8854 return resultobj;
8855 fail:
8856 return NULL;
8857 }
8858
8859
8860 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8861 PyObject *resultobj = 0;
8862 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8863 wxPoint2D *arg2 = 0 ;
8864 wxPoint2D *result = 0 ;
8865 void *argp1 = 0 ;
8866 int res1 = 0 ;
8867 wxPoint2D temp2 ;
8868 PyObject * obj0 = 0 ;
8869 PyObject * obj1 = 0 ;
8870 char * kwnames[] = {
8871 (char *) "self",(char *) "pt", NULL
8872 };
8873
8874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8876 if (!SWIG_IsOK(res1)) {
8877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8878 }
8879 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8880 {
8881 arg2 = &temp2;
8882 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8883 }
8884 {
8885 PyThreadState* __tstate = wxPyBeginAllowThreads();
8886 {
8887 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8888 result = (wxPoint2D *) &_result_ref;
8889 }
8890 wxPyEndAllowThreads(__tstate);
8891 if (PyErr_Occurred()) SWIG_fail;
8892 }
8893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8894 return resultobj;
8895 fail:
8896 return NULL;
8897 }
8898
8899
8900 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8901 PyObject *resultobj = 0;
8902 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8903 wxPoint2D *arg2 = 0 ;
8904 wxPoint2D *result = 0 ;
8905 void *argp1 = 0 ;
8906 int res1 = 0 ;
8907 wxPoint2D temp2 ;
8908 PyObject * obj0 = 0 ;
8909 PyObject * obj1 = 0 ;
8910 char * kwnames[] = {
8911 (char *) "self",(char *) "pt", NULL
8912 };
8913
8914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8916 if (!SWIG_IsOK(res1)) {
8917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8918 }
8919 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8920 {
8921 arg2 = &temp2;
8922 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8923 }
8924 {
8925 PyThreadState* __tstate = wxPyBeginAllowThreads();
8926 {
8927 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8928 result = (wxPoint2D *) &_result_ref;
8929 }
8930 wxPyEndAllowThreads(__tstate);
8931 if (PyErr_Occurred()) SWIG_fail;
8932 }
8933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8934 return resultobj;
8935 fail:
8936 return NULL;
8937 }
8938
8939
8940 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8941 PyObject *resultobj = 0;
8942 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8943 PyObject *arg2 = (PyObject *) 0 ;
8944 bool result;
8945 void *argp1 = 0 ;
8946 int res1 = 0 ;
8947 PyObject * obj0 = 0 ;
8948 PyObject * obj1 = 0 ;
8949 char * kwnames[] = {
8950 (char *) "self",(char *) "other", NULL
8951 };
8952
8953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8955 if (!SWIG_IsOK(res1)) {
8956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8957 }
8958 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8959 arg2 = obj1;
8960 {
8961 result = (bool)wxPoint2D___eq__(arg1,arg2);
8962 if (PyErr_Occurred()) SWIG_fail;
8963 }
8964 {
8965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8966 }
8967 return resultobj;
8968 fail:
8969 return NULL;
8970 }
8971
8972
8973 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8974 PyObject *resultobj = 0;
8975 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8976 PyObject *arg2 = (PyObject *) 0 ;
8977 bool result;
8978 void *argp1 = 0 ;
8979 int res1 = 0 ;
8980 PyObject * obj0 = 0 ;
8981 PyObject * obj1 = 0 ;
8982 char * kwnames[] = {
8983 (char *) "self",(char *) "other", NULL
8984 };
8985
8986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8988 if (!SWIG_IsOK(res1)) {
8989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8990 }
8991 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8992 arg2 = obj1;
8993 {
8994 result = (bool)wxPoint2D___ne__(arg1,arg2);
8995 if (PyErr_Occurred()) SWIG_fail;
8996 }
8997 {
8998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8999 }
9000 return resultobj;
9001 fail:
9002 return NULL;
9003 }
9004
9005
9006 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9007 PyObject *resultobj = 0;
9008 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9009 double arg2 ;
9010 void *argp1 = 0 ;
9011 int res1 = 0 ;
9012 double val2 ;
9013 int ecode2 = 0 ;
9014 PyObject *swig_obj[2] ;
9015
9016 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9018 if (!SWIG_IsOK(res1)) {
9019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9020 }
9021 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9022 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9023 if (!SWIG_IsOK(ecode2)) {
9024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9025 }
9026 arg2 = static_cast< double >(val2);
9027 if (arg1) (arg1)->m_x = arg2;
9028
9029 resultobj = SWIG_Py_Void();
9030 return resultobj;
9031 fail:
9032 return NULL;
9033 }
9034
9035
9036 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9037 PyObject *resultobj = 0;
9038 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9039 double result;
9040 void *argp1 = 0 ;
9041 int res1 = 0 ;
9042 PyObject *swig_obj[1] ;
9043
9044 if (!args) SWIG_fail;
9045 swig_obj[0] = args;
9046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9047 if (!SWIG_IsOK(res1)) {
9048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9049 }
9050 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9051 result = (double) ((arg1)->m_x);
9052 resultobj = SWIG_From_double(static_cast< double >(result));
9053 return resultobj;
9054 fail:
9055 return NULL;
9056 }
9057
9058
9059 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9060 PyObject *resultobj = 0;
9061 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9062 double arg2 ;
9063 void *argp1 = 0 ;
9064 int res1 = 0 ;
9065 double val2 ;
9066 int ecode2 = 0 ;
9067 PyObject *swig_obj[2] ;
9068
9069 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9071 if (!SWIG_IsOK(res1)) {
9072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9073 }
9074 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9075 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9076 if (!SWIG_IsOK(ecode2)) {
9077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9078 }
9079 arg2 = static_cast< double >(val2);
9080 if (arg1) (arg1)->m_y = arg2;
9081
9082 resultobj = SWIG_Py_Void();
9083 return resultobj;
9084 fail:
9085 return NULL;
9086 }
9087
9088
9089 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9090 PyObject *resultobj = 0;
9091 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9092 double result;
9093 void *argp1 = 0 ;
9094 int res1 = 0 ;
9095 PyObject *swig_obj[1] ;
9096
9097 if (!args) SWIG_fail;
9098 swig_obj[0] = args;
9099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9100 if (!SWIG_IsOK(res1)) {
9101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9102 }
9103 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9104 result = (double) ((arg1)->m_y);
9105 resultobj = SWIG_From_double(static_cast< double >(result));
9106 return resultobj;
9107 fail:
9108 return NULL;
9109 }
9110
9111
9112 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9113 PyObject *resultobj = 0;
9114 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9115 double arg2 = (double) 0 ;
9116 double arg3 = (double) 0 ;
9117 void *argp1 = 0 ;
9118 int res1 = 0 ;
9119 double val2 ;
9120 int ecode2 = 0 ;
9121 double val3 ;
9122 int ecode3 = 0 ;
9123 PyObject * obj0 = 0 ;
9124 PyObject * obj1 = 0 ;
9125 PyObject * obj2 = 0 ;
9126 char * kwnames[] = {
9127 (char *) "self",(char *) "x",(char *) "y", NULL
9128 };
9129
9130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9132 if (!SWIG_IsOK(res1)) {
9133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9134 }
9135 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9136 if (obj1) {
9137 ecode2 = SWIG_AsVal_double(obj1, &val2);
9138 if (!SWIG_IsOK(ecode2)) {
9139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9140 }
9141 arg2 = static_cast< double >(val2);
9142 }
9143 if (obj2) {
9144 ecode3 = SWIG_AsVal_double(obj2, &val3);
9145 if (!SWIG_IsOK(ecode3)) {
9146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9147 }
9148 arg3 = static_cast< double >(val3);
9149 }
9150 {
9151 PyThreadState* __tstate = wxPyBeginAllowThreads();
9152 wxPoint2D_Set(arg1,arg2,arg3);
9153 wxPyEndAllowThreads(__tstate);
9154 if (PyErr_Occurred()) SWIG_fail;
9155 }
9156 resultobj = SWIG_Py_Void();
9157 return resultobj;
9158 fail:
9159 return NULL;
9160 }
9161
9162
9163 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9164 PyObject *resultobj = 0;
9165 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9166 PyObject *result = 0 ;
9167 void *argp1 = 0 ;
9168 int res1 = 0 ;
9169 PyObject *swig_obj[1] ;
9170
9171 if (!args) SWIG_fail;
9172 swig_obj[0] = args;
9173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9174 if (!SWIG_IsOK(res1)) {
9175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9176 }
9177 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9178 {
9179 PyThreadState* __tstate = wxPyBeginAllowThreads();
9180 result = (PyObject *)wxPoint2D_Get(arg1);
9181 wxPyEndAllowThreads(__tstate);
9182 if (PyErr_Occurred()) SWIG_fail;
9183 }
9184 resultobj = result;
9185 return resultobj;
9186 fail:
9187 return NULL;
9188 }
9189
9190
9191 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9192 PyObject *obj;
9193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9194 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9195 return SWIG_Py_Void();
9196 }
9197
9198 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9199 return SWIG_Python_InitShadowInstance(args);
9200 }
9201
9202 SWIGINTERN int DefaultPosition_set(PyObject *) {
9203 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
9204 return 1;
9205 }
9206
9207
9208 SWIGINTERN PyObject *DefaultPosition_get(void) {
9209 PyObject *pyobj = 0;
9210
9211 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9212 return pyobj;
9213 }
9214
9215
9216 SWIGINTERN int DefaultSize_set(PyObject *) {
9217 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9218 return 1;
9219 }
9220
9221
9222 SWIGINTERN PyObject *DefaultSize_get(void) {
9223 PyObject *pyobj = 0;
9224
9225 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9226 return pyobj;
9227 }
9228
9229
9230 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9231 PyObject *resultobj = 0;
9232 PyObject *arg1 = (PyObject *) 0 ;
9233 wxPyInputStream *result = 0 ;
9234 PyObject * obj0 = 0 ;
9235 char * kwnames[] = {
9236 (char *) "p", NULL
9237 };
9238
9239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9240 arg1 = obj0;
9241 {
9242 PyThreadState* __tstate = wxPyBeginAllowThreads();
9243 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9244 wxPyEndAllowThreads(__tstate);
9245 if (PyErr_Occurred()) SWIG_fail;
9246 }
9247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9248 return resultobj;
9249 fail:
9250 return NULL;
9251 }
9252
9253
9254 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9255 PyObject *resultobj = 0;
9256 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9257 void *argp1 = 0 ;
9258 int res1 = 0 ;
9259 PyObject *swig_obj[1] ;
9260
9261 if (!args) SWIG_fail;
9262 swig_obj[0] = args;
9263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9264 if (!SWIG_IsOK(res1)) {
9265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9266 }
9267 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9268 {
9269 PyThreadState* __tstate = wxPyBeginAllowThreads();
9270 delete arg1;
9271
9272 wxPyEndAllowThreads(__tstate);
9273 if (PyErr_Occurred()) SWIG_fail;
9274 }
9275 resultobj = SWIG_Py_Void();
9276 return resultobj;
9277 fail:
9278 return NULL;
9279 }
9280
9281
9282 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9283 PyObject *resultobj = 0;
9284 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9285 void *argp1 = 0 ;
9286 int res1 = 0 ;
9287 PyObject *swig_obj[1] ;
9288
9289 if (!args) SWIG_fail;
9290 swig_obj[0] = args;
9291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9292 if (!SWIG_IsOK(res1)) {
9293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9294 }
9295 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9296 {
9297 PyThreadState* __tstate = wxPyBeginAllowThreads();
9298 (arg1)->close();
9299 wxPyEndAllowThreads(__tstate);
9300 if (PyErr_Occurred()) SWIG_fail;
9301 }
9302 resultobj = SWIG_Py_Void();
9303 return resultobj;
9304 fail:
9305 return NULL;
9306 }
9307
9308
9309 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9310 PyObject *resultobj = 0;
9311 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9312 void *argp1 = 0 ;
9313 int res1 = 0 ;
9314 PyObject *swig_obj[1] ;
9315
9316 if (!args) SWIG_fail;
9317 swig_obj[0] = args;
9318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9319 if (!SWIG_IsOK(res1)) {
9320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9321 }
9322 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9323 {
9324 PyThreadState* __tstate = wxPyBeginAllowThreads();
9325 (arg1)->flush();
9326 wxPyEndAllowThreads(__tstate);
9327 if (PyErr_Occurred()) SWIG_fail;
9328 }
9329 resultobj = SWIG_Py_Void();
9330 return resultobj;
9331 fail:
9332 return NULL;
9333 }
9334
9335
9336 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9337 PyObject *resultobj = 0;
9338 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9339 bool result;
9340 void *argp1 = 0 ;
9341 int res1 = 0 ;
9342 PyObject *swig_obj[1] ;
9343
9344 if (!args) SWIG_fail;
9345 swig_obj[0] = args;
9346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9347 if (!SWIG_IsOK(res1)) {
9348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9349 }
9350 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9351 {
9352 PyThreadState* __tstate = wxPyBeginAllowThreads();
9353 result = (bool)(arg1)->eof();
9354 wxPyEndAllowThreads(__tstate);
9355 if (PyErr_Occurred()) SWIG_fail;
9356 }
9357 {
9358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9359 }
9360 return resultobj;
9361 fail:
9362 return NULL;
9363 }
9364
9365
9366 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9367 PyObject *resultobj = 0;
9368 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9369 int arg2 = (int) -1 ;
9370 PyObject *result = 0 ;
9371 void *argp1 = 0 ;
9372 int res1 = 0 ;
9373 int val2 ;
9374 int ecode2 = 0 ;
9375 PyObject * obj0 = 0 ;
9376 PyObject * obj1 = 0 ;
9377 char * kwnames[] = {
9378 (char *) "self",(char *) "size", NULL
9379 };
9380
9381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9383 if (!SWIG_IsOK(res1)) {
9384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9385 }
9386 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9387 if (obj1) {
9388 ecode2 = SWIG_AsVal_int(obj1, &val2);
9389 if (!SWIG_IsOK(ecode2)) {
9390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9391 }
9392 arg2 = static_cast< int >(val2);
9393 }
9394 {
9395 PyThreadState* __tstate = wxPyBeginAllowThreads();
9396 result = (PyObject *)(arg1)->read(arg2);
9397 wxPyEndAllowThreads(__tstate);
9398 if (PyErr_Occurred()) SWIG_fail;
9399 }
9400 resultobj = result;
9401 return resultobj;
9402 fail:
9403 return NULL;
9404 }
9405
9406
9407 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9408 PyObject *resultobj = 0;
9409 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9410 int arg2 = (int) -1 ;
9411 PyObject *result = 0 ;
9412 void *argp1 = 0 ;
9413 int res1 = 0 ;
9414 int val2 ;
9415 int ecode2 = 0 ;
9416 PyObject * obj0 = 0 ;
9417 PyObject * obj1 = 0 ;
9418 char * kwnames[] = {
9419 (char *) "self",(char *) "size", NULL
9420 };
9421
9422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9424 if (!SWIG_IsOK(res1)) {
9425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9426 }
9427 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9428 if (obj1) {
9429 ecode2 = SWIG_AsVal_int(obj1, &val2);
9430 if (!SWIG_IsOK(ecode2)) {
9431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9432 }
9433 arg2 = static_cast< int >(val2);
9434 }
9435 {
9436 PyThreadState* __tstate = wxPyBeginAllowThreads();
9437 result = (PyObject *)(arg1)->readline(arg2);
9438 wxPyEndAllowThreads(__tstate);
9439 if (PyErr_Occurred()) SWIG_fail;
9440 }
9441 resultobj = result;
9442 return resultobj;
9443 fail:
9444 return NULL;
9445 }
9446
9447
9448 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9449 PyObject *resultobj = 0;
9450 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9451 int arg2 = (int) -1 ;
9452 PyObject *result = 0 ;
9453 void *argp1 = 0 ;
9454 int res1 = 0 ;
9455 int val2 ;
9456 int ecode2 = 0 ;
9457 PyObject * obj0 = 0 ;
9458 PyObject * obj1 = 0 ;
9459 char * kwnames[] = {
9460 (char *) "self",(char *) "sizehint", NULL
9461 };
9462
9463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9465 if (!SWIG_IsOK(res1)) {
9466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9467 }
9468 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9469 if (obj1) {
9470 ecode2 = SWIG_AsVal_int(obj1, &val2);
9471 if (!SWIG_IsOK(ecode2)) {
9472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9473 }
9474 arg2 = static_cast< int >(val2);
9475 }
9476 {
9477 PyThreadState* __tstate = wxPyBeginAllowThreads();
9478 result = (PyObject *)(arg1)->readlines(arg2);
9479 wxPyEndAllowThreads(__tstate);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 resultobj = result;
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj = 0;
9491 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9492 int arg2 ;
9493 int arg3 = (int) 0 ;
9494 void *argp1 = 0 ;
9495 int res1 = 0 ;
9496 int val2 ;
9497 int ecode2 = 0 ;
9498 int val3 ;
9499 int ecode3 = 0 ;
9500 PyObject * obj0 = 0 ;
9501 PyObject * obj1 = 0 ;
9502 PyObject * obj2 = 0 ;
9503 char * kwnames[] = {
9504 (char *) "self",(char *) "offset",(char *) "whence", NULL
9505 };
9506
9507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9509 if (!SWIG_IsOK(res1)) {
9510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9511 }
9512 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9513 ecode2 = SWIG_AsVal_int(obj1, &val2);
9514 if (!SWIG_IsOK(ecode2)) {
9515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9516 }
9517 arg2 = static_cast< int >(val2);
9518 if (obj2) {
9519 ecode3 = SWIG_AsVal_int(obj2, &val3);
9520 if (!SWIG_IsOK(ecode3)) {
9521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9522 }
9523 arg3 = static_cast< int >(val3);
9524 }
9525 {
9526 PyThreadState* __tstate = wxPyBeginAllowThreads();
9527 (arg1)->seek(arg2,arg3);
9528 wxPyEndAllowThreads(__tstate);
9529 if (PyErr_Occurred()) SWIG_fail;
9530 }
9531 resultobj = SWIG_Py_Void();
9532 return resultobj;
9533 fail:
9534 return NULL;
9535 }
9536
9537
9538 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9539 PyObject *resultobj = 0;
9540 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9541 int result;
9542 void *argp1 = 0 ;
9543 int res1 = 0 ;
9544 PyObject *swig_obj[1] ;
9545
9546 if (!args) SWIG_fail;
9547 swig_obj[0] = args;
9548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9549 if (!SWIG_IsOK(res1)) {
9550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9551 }
9552 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9553 {
9554 PyThreadState* __tstate = wxPyBeginAllowThreads();
9555 result = (int)(arg1)->tell();
9556 wxPyEndAllowThreads(__tstate);
9557 if (PyErr_Occurred()) SWIG_fail;
9558 }
9559 resultobj = SWIG_From_int(static_cast< int >(result));
9560 return resultobj;
9561 fail:
9562 return NULL;
9563 }
9564
9565
9566 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9567 PyObject *resultobj = 0;
9568 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9569 char result;
9570 void *argp1 = 0 ;
9571 int res1 = 0 ;
9572 PyObject *swig_obj[1] ;
9573
9574 if (!args) SWIG_fail;
9575 swig_obj[0] = args;
9576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9577 if (!SWIG_IsOK(res1)) {
9578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9579 }
9580 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9581 {
9582 PyThreadState* __tstate = wxPyBeginAllowThreads();
9583 result = (char)(arg1)->Peek();
9584 wxPyEndAllowThreads(__tstate);
9585 if (PyErr_Occurred()) SWIG_fail;
9586 }
9587 resultobj = SWIG_From_char(static_cast< char >(result));
9588 return resultobj;
9589 fail:
9590 return NULL;
9591 }
9592
9593
9594 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9595 PyObject *resultobj = 0;
9596 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9597 char result;
9598 void *argp1 = 0 ;
9599 int res1 = 0 ;
9600 PyObject *swig_obj[1] ;
9601
9602 if (!args) SWIG_fail;
9603 swig_obj[0] = args;
9604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9605 if (!SWIG_IsOK(res1)) {
9606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9607 }
9608 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9609 {
9610 PyThreadState* __tstate = wxPyBeginAllowThreads();
9611 result = (char)(arg1)->GetC();
9612 wxPyEndAllowThreads(__tstate);
9613 if (PyErr_Occurred()) SWIG_fail;
9614 }
9615 resultobj = SWIG_From_char(static_cast< char >(result));
9616 return resultobj;
9617 fail:
9618 return NULL;
9619 }
9620
9621
9622 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9623 PyObject *resultobj = 0;
9624 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9625 size_t result;
9626 void *argp1 = 0 ;
9627 int res1 = 0 ;
9628 PyObject *swig_obj[1] ;
9629
9630 if (!args) SWIG_fail;
9631 swig_obj[0] = args;
9632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9633 if (!SWIG_IsOK(res1)) {
9634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9635 }
9636 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9637 {
9638 PyThreadState* __tstate = wxPyBeginAllowThreads();
9639 result = (size_t)(arg1)->LastRead();
9640 wxPyEndAllowThreads(__tstate);
9641 if (PyErr_Occurred()) SWIG_fail;
9642 }
9643 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9644 return resultobj;
9645 fail:
9646 return NULL;
9647 }
9648
9649
9650 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9651 PyObject *resultobj = 0;
9652 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9653 bool result;
9654 void *argp1 = 0 ;
9655 int res1 = 0 ;
9656 PyObject *swig_obj[1] ;
9657
9658 if (!args) SWIG_fail;
9659 swig_obj[0] = args;
9660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9661 if (!SWIG_IsOK(res1)) {
9662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9663 }
9664 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9665 {
9666 PyThreadState* __tstate = wxPyBeginAllowThreads();
9667 result = (bool)(arg1)->CanRead();
9668 wxPyEndAllowThreads(__tstate);
9669 if (PyErr_Occurred()) SWIG_fail;
9670 }
9671 {
9672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9673 }
9674 return resultobj;
9675 fail:
9676 return NULL;
9677 }
9678
9679
9680 SWIGINTERN PyObject *_wrap_InputStream_Eof(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_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9693 }
9694 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9695 {
9696 PyThreadState* __tstate = wxPyBeginAllowThreads();
9697 result = (bool)(arg1)->Eof();
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_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9711 PyObject *resultobj = 0;
9712 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9713 char arg2 ;
9714 bool result;
9715 void *argp1 = 0 ;
9716 int res1 = 0 ;
9717 char val2 ;
9718 int ecode2 = 0 ;
9719 PyObject * obj0 = 0 ;
9720 PyObject * obj1 = 0 ;
9721 char * kwnames[] = {
9722 (char *) "self",(char *) "c", NULL
9723 };
9724
9725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9727 if (!SWIG_IsOK(res1)) {
9728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9729 }
9730 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9731 ecode2 = SWIG_AsVal_char(obj1, &val2);
9732 if (!SWIG_IsOK(ecode2)) {
9733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9734 }
9735 arg2 = static_cast< char >(val2);
9736 {
9737 PyThreadState* __tstate = wxPyBeginAllowThreads();
9738 result = (bool)(arg1)->Ungetch(arg2);
9739 wxPyEndAllowThreads(__tstate);
9740 if (PyErr_Occurred()) SWIG_fail;
9741 }
9742 {
9743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9744 }
9745 return resultobj;
9746 fail:
9747 return NULL;
9748 }
9749
9750
9751 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9752 PyObject *resultobj = 0;
9753 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9754 long arg2 ;
9755 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9756 long result;
9757 void *argp1 = 0 ;
9758 int res1 = 0 ;
9759 long val2 ;
9760 int ecode2 = 0 ;
9761 int val3 ;
9762 int ecode3 = 0 ;
9763 PyObject * obj0 = 0 ;
9764 PyObject * obj1 = 0 ;
9765 PyObject * obj2 = 0 ;
9766 char * kwnames[] = {
9767 (char *) "self",(char *) "pos",(char *) "mode", NULL
9768 };
9769
9770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9772 if (!SWIG_IsOK(res1)) {
9773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9774 }
9775 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9776 ecode2 = SWIG_AsVal_long(obj1, &val2);
9777 if (!SWIG_IsOK(ecode2)) {
9778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9779 }
9780 arg2 = static_cast< long >(val2);
9781 if (obj2) {
9782 ecode3 = SWIG_AsVal_int(obj2, &val3);
9783 if (!SWIG_IsOK(ecode3)) {
9784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9785 }
9786 arg3 = static_cast< wxSeekMode >(val3);
9787 }
9788 {
9789 PyThreadState* __tstate = wxPyBeginAllowThreads();
9790 result = (long)(arg1)->SeekI(arg2,arg3);
9791 wxPyEndAllowThreads(__tstate);
9792 if (PyErr_Occurred()) SWIG_fail;
9793 }
9794 resultobj = SWIG_From_long(static_cast< long >(result));
9795 return resultobj;
9796 fail:
9797 return NULL;
9798 }
9799
9800
9801 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9802 PyObject *resultobj = 0;
9803 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9804 long result;
9805 void *argp1 = 0 ;
9806 int res1 = 0 ;
9807 PyObject *swig_obj[1] ;
9808
9809 if (!args) SWIG_fail;
9810 swig_obj[0] = args;
9811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9812 if (!SWIG_IsOK(res1)) {
9813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9814 }
9815 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9816 {
9817 PyThreadState* __tstate = wxPyBeginAllowThreads();
9818 result = (long)(arg1)->TellI();
9819 wxPyEndAllowThreads(__tstate);
9820 if (PyErr_Occurred()) SWIG_fail;
9821 }
9822 resultobj = SWIG_From_long(static_cast< long >(result));
9823 return resultobj;
9824 fail:
9825 return NULL;
9826 }
9827
9828
9829 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9830 PyObject *obj;
9831 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9832 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9833 return SWIG_Py_Void();
9834 }
9835
9836 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9837 return SWIG_Python_InitShadowInstance(args);
9838 }
9839
9840 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9841 PyObject *resultobj = 0;
9842 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9843 PyObject *arg2 = (PyObject *) 0 ;
9844 void *argp1 = 0 ;
9845 int res1 = 0 ;
9846 PyObject * obj0 = 0 ;
9847 PyObject * obj1 = 0 ;
9848 char * kwnames[] = {
9849 (char *) "self",(char *) "obj", NULL
9850 };
9851
9852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9854 if (!SWIG_IsOK(res1)) {
9855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9856 }
9857 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9858 arg2 = obj1;
9859 {
9860 PyThreadState* __tstate = wxPyBeginAllowThreads();
9861 wxOutputStream_write(arg1,arg2);
9862 wxPyEndAllowThreads(__tstate);
9863 if (PyErr_Occurred()) SWIG_fail;
9864 }
9865 resultobj = SWIG_Py_Void();
9866 return resultobj;
9867 fail:
9868 return NULL;
9869 }
9870
9871
9872 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9873 PyObject *resultobj = 0;
9874 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9875 size_t result;
9876 void *argp1 = 0 ;
9877 int res1 = 0 ;
9878 PyObject *swig_obj[1] ;
9879
9880 if (!args) SWIG_fail;
9881 swig_obj[0] = args;
9882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9883 if (!SWIG_IsOK(res1)) {
9884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9885 }
9886 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9887 {
9888 PyThreadState* __tstate = wxPyBeginAllowThreads();
9889 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9890 wxPyEndAllowThreads(__tstate);
9891 if (PyErr_Occurred()) SWIG_fail;
9892 }
9893 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9894 return resultobj;
9895 fail:
9896 return NULL;
9897 }
9898
9899
9900 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9901 PyObject *obj;
9902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9903 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9904 return SWIG_Py_Void();
9905 }
9906
9907 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9908 PyObject *resultobj = 0;
9909 wxInputStream *arg1 = (wxInputStream *) 0 ;
9910 wxString *arg2 = 0 ;
9911 wxString *arg3 = 0 ;
9912 wxString *arg4 = 0 ;
9913 wxDateTime arg5 ;
9914 wxFSFile *result = 0 ;
9915 wxPyInputStream *temp1 ;
9916 bool temp2 = false ;
9917 bool temp3 = false ;
9918 bool temp4 = false ;
9919 void *argp5 ;
9920 int res5 = 0 ;
9921 PyObject * obj0 = 0 ;
9922 PyObject * obj1 = 0 ;
9923 PyObject * obj2 = 0 ;
9924 PyObject * obj3 = 0 ;
9925 PyObject * obj4 = 0 ;
9926 char * kwnames[] = {
9927 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9928 };
9929
9930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9931 {
9932 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9933 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9934 } else {
9935 PyErr_Clear(); // clear the failure of the wxPyConvert above
9936 arg1 = wxPyCBInputStream_create(obj0, true);
9937 if (arg1 == NULL) {
9938 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9939 SWIG_fail;
9940 }
9941 }
9942 }
9943 {
9944 arg2 = wxString_in_helper(obj1);
9945 if (arg2 == NULL) SWIG_fail;
9946 temp2 = true;
9947 }
9948 {
9949 arg3 = wxString_in_helper(obj2);
9950 if (arg3 == NULL) SWIG_fail;
9951 temp3 = true;
9952 }
9953 {
9954 arg4 = wxString_in_helper(obj3);
9955 if (arg4 == NULL) SWIG_fail;
9956 temp4 = true;
9957 }
9958 {
9959 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9960 if (!SWIG_IsOK(res5)) {
9961 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9962 }
9963 if (!argp5) {
9964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9965 } else {
9966 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9967 arg5 = *temp;
9968 if (SWIG_IsNewObj(res5)) delete temp;
9969 }
9970 }
9971 {
9972 PyThreadState* __tstate = wxPyBeginAllowThreads();
9973 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9974 wxPyEndAllowThreads(__tstate);
9975 if (PyErr_Occurred()) SWIG_fail;
9976 }
9977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9978 {
9979 if (temp2)
9980 delete arg2;
9981 }
9982 {
9983 if (temp3)
9984 delete arg3;
9985 }
9986 {
9987 if (temp4)
9988 delete arg4;
9989 }
9990 return resultobj;
9991 fail:
9992 {
9993 if (temp2)
9994 delete arg2;
9995 }
9996 {
9997 if (temp3)
9998 delete arg3;
9999 }
10000 {
10001 if (temp4)
10002 delete arg4;
10003 }
10004 return NULL;
10005 }
10006
10007
10008 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10009 PyObject *resultobj = 0;
10010 wxFSFile *arg1 = (wxFSFile *) 0 ;
10011 void *argp1 = 0 ;
10012 int res1 = 0 ;
10013 PyObject *swig_obj[1] ;
10014
10015 if (!args) SWIG_fail;
10016 swig_obj[0] = args;
10017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
10018 if (!SWIG_IsOK(res1)) {
10019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
10020 }
10021 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10022 {
10023 PyThreadState* __tstate = wxPyBeginAllowThreads();
10024 delete arg1;
10025
10026 wxPyEndAllowThreads(__tstate);
10027 if (PyErr_Occurred()) SWIG_fail;
10028 }
10029 resultobj = SWIG_Py_Void();
10030 return resultobj;
10031 fail:
10032 return NULL;
10033 }
10034
10035
10036 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10037 PyObject *resultobj = 0;
10038 wxFSFile *arg1 = (wxFSFile *) 0 ;
10039 wxInputStream *result = 0 ;
10040 void *argp1 = 0 ;
10041 int res1 = 0 ;
10042 PyObject *swig_obj[1] ;
10043
10044 if (!args) SWIG_fail;
10045 swig_obj[0] = args;
10046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10047 if (!SWIG_IsOK(res1)) {
10048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10049 }
10050 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10051 {
10052 PyThreadState* __tstate = wxPyBeginAllowThreads();
10053 result = (wxInputStream *)(arg1)->GetStream();
10054 wxPyEndAllowThreads(__tstate);
10055 if (PyErr_Occurred()) SWIG_fail;
10056 }
10057 {
10058 wxPyInputStream * _ptr = NULL;
10059
10060 if (result) {
10061 _ptr = new wxPyInputStream(result);
10062 }
10063 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10064 }
10065 return resultobj;
10066 fail:
10067 return NULL;
10068 }
10069
10070
10071 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10072 PyObject *resultobj = 0;
10073 wxFSFile *arg1 = (wxFSFile *) 0 ;
10074 void *argp1 = 0 ;
10075 int res1 = 0 ;
10076 PyObject *swig_obj[1] ;
10077
10078 if (!args) SWIG_fail;
10079 swig_obj[0] = args;
10080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10081 if (!SWIG_IsOK(res1)) {
10082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10083 }
10084 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10085 {
10086 PyThreadState* __tstate = wxPyBeginAllowThreads();
10087 (arg1)->DetachStream();
10088 wxPyEndAllowThreads(__tstate);
10089 if (PyErr_Occurred()) SWIG_fail;
10090 }
10091 resultobj = SWIG_Py_Void();
10092 return resultobj;
10093 fail:
10094 return NULL;
10095 }
10096
10097
10098 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10099 PyObject *resultobj = 0;
10100 wxFSFile *arg1 = (wxFSFile *) 0 ;
10101 wxString *result = 0 ;
10102 void *argp1 = 0 ;
10103 int res1 = 0 ;
10104 PyObject *swig_obj[1] ;
10105
10106 if (!args) SWIG_fail;
10107 swig_obj[0] = args;
10108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10109 if (!SWIG_IsOK(res1)) {
10110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
10111 }
10112 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10113 {
10114 PyThreadState* __tstate = wxPyBeginAllowThreads();
10115 {
10116 wxString const &_result_ref = (arg1)->GetMimeType();
10117 result = (wxString *) &_result_ref;
10118 }
10119 wxPyEndAllowThreads(__tstate);
10120 if (PyErr_Occurred()) SWIG_fail;
10121 }
10122 {
10123 #if wxUSE_UNICODE
10124 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10125 #else
10126 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10127 #endif
10128 }
10129 return resultobj;
10130 fail:
10131 return NULL;
10132 }
10133
10134
10135 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10136 PyObject *resultobj = 0;
10137 wxFSFile *arg1 = (wxFSFile *) 0 ;
10138 wxString *result = 0 ;
10139 void *argp1 = 0 ;
10140 int res1 = 0 ;
10141 PyObject *swig_obj[1] ;
10142
10143 if (!args) SWIG_fail;
10144 swig_obj[0] = args;
10145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10146 if (!SWIG_IsOK(res1)) {
10147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
10148 }
10149 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10150 {
10151 PyThreadState* __tstate = wxPyBeginAllowThreads();
10152 {
10153 wxString const &_result_ref = (arg1)->GetLocation();
10154 result = (wxString *) &_result_ref;
10155 }
10156 wxPyEndAllowThreads(__tstate);
10157 if (PyErr_Occurred()) SWIG_fail;
10158 }
10159 {
10160 #if wxUSE_UNICODE
10161 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10162 #else
10163 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10164 #endif
10165 }
10166 return resultobj;
10167 fail:
10168 return NULL;
10169 }
10170
10171
10172 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10173 PyObject *resultobj = 0;
10174 wxFSFile *arg1 = (wxFSFile *) 0 ;
10175 wxString *result = 0 ;
10176 void *argp1 = 0 ;
10177 int res1 = 0 ;
10178 PyObject *swig_obj[1] ;
10179
10180 if (!args) SWIG_fail;
10181 swig_obj[0] = args;
10182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10183 if (!SWIG_IsOK(res1)) {
10184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
10185 }
10186 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10187 {
10188 PyThreadState* __tstate = wxPyBeginAllowThreads();
10189 {
10190 wxString const &_result_ref = (arg1)->GetAnchor();
10191 result = (wxString *) &_result_ref;
10192 }
10193 wxPyEndAllowThreads(__tstate);
10194 if (PyErr_Occurred()) SWIG_fail;
10195 }
10196 {
10197 #if wxUSE_UNICODE
10198 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10199 #else
10200 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10201 #endif
10202 }
10203 return resultobj;
10204 fail:
10205 return NULL;
10206 }
10207
10208
10209 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10210 PyObject *resultobj = 0;
10211 wxFSFile *arg1 = (wxFSFile *) 0 ;
10212 wxDateTime result;
10213 void *argp1 = 0 ;
10214 int res1 = 0 ;
10215 PyObject *swig_obj[1] ;
10216
10217 if (!args) SWIG_fail;
10218 swig_obj[0] = args;
10219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10220 if (!SWIG_IsOK(res1)) {
10221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10222 }
10223 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10224 {
10225 PyThreadState* __tstate = wxPyBeginAllowThreads();
10226 result = (arg1)->GetModificationTime();
10227 wxPyEndAllowThreads(__tstate);
10228 if (PyErr_Occurred()) SWIG_fail;
10229 }
10230 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10231 return resultobj;
10232 fail:
10233 return NULL;
10234 }
10235
10236
10237 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10238 PyObject *obj;
10239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10240 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10241 return SWIG_Py_Void();
10242 }
10243
10244 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10245 return SWIG_Python_InitShadowInstance(args);
10246 }
10247
10248 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10249 PyObject *resultobj = 0;
10250 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10251 void *argp1 = 0 ;
10252 int res1 = 0 ;
10253 PyObject *swig_obj[1] ;
10254
10255 if (!args) SWIG_fail;
10256 swig_obj[0] = args;
10257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10258 if (!SWIG_IsOK(res1)) {
10259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10260 }
10261 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10262 {
10263 PyThreadState* __tstate = wxPyBeginAllowThreads();
10264 delete arg1;
10265
10266 wxPyEndAllowThreads(__tstate);
10267 if (PyErr_Occurred()) SWIG_fail;
10268 }
10269 resultobj = SWIG_Py_Void();
10270 return resultobj;
10271 fail:
10272 return NULL;
10273 }
10274
10275
10276 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10277 PyObject *obj;
10278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10279 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10280 return SWIG_Py_Void();
10281 }
10282
10283 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10284 PyObject *resultobj = 0;
10285 wxPyFileSystemHandler *result = 0 ;
10286
10287 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10288 {
10289 PyThreadState* __tstate = wxPyBeginAllowThreads();
10290 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10291 wxPyEndAllowThreads(__tstate);
10292 if (PyErr_Occurred()) SWIG_fail;
10293 }
10294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10295 return resultobj;
10296 fail:
10297 return NULL;
10298 }
10299
10300
10301 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10302 PyObject *resultobj = 0;
10303 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10304 PyObject *arg2 = (PyObject *) 0 ;
10305 PyObject *arg3 = (PyObject *) 0 ;
10306 void *argp1 = 0 ;
10307 int res1 = 0 ;
10308 PyObject * obj0 = 0 ;
10309 PyObject * obj1 = 0 ;
10310 PyObject * obj2 = 0 ;
10311 char * kwnames[] = {
10312 (char *) "self",(char *) "self",(char *) "_class", NULL
10313 };
10314
10315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10317 if (!SWIG_IsOK(res1)) {
10318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10319 }
10320 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10321 arg2 = obj1;
10322 arg3 = obj2;
10323 {
10324 PyThreadState* __tstate = wxPyBeginAllowThreads();
10325 (arg1)->_setCallbackInfo(arg2,arg3);
10326 wxPyEndAllowThreads(__tstate);
10327 if (PyErr_Occurred()) SWIG_fail;
10328 }
10329 resultobj = SWIG_Py_Void();
10330 return resultobj;
10331 fail:
10332 return NULL;
10333 }
10334
10335
10336 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10337 PyObject *resultobj = 0;
10338 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10339 wxString *arg2 = 0 ;
10340 bool result;
10341 void *argp1 = 0 ;
10342 int res1 = 0 ;
10343 bool temp2 = false ;
10344 PyObject * obj0 = 0 ;
10345 PyObject * obj1 = 0 ;
10346 char * kwnames[] = {
10347 (char *) "self",(char *) "location", NULL
10348 };
10349
10350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10352 if (!SWIG_IsOK(res1)) {
10353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10354 }
10355 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10356 {
10357 arg2 = wxString_in_helper(obj1);
10358 if (arg2 == NULL) SWIG_fail;
10359 temp2 = true;
10360 }
10361 {
10362 PyThreadState* __tstate = wxPyBeginAllowThreads();
10363 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10364 wxPyEndAllowThreads(__tstate);
10365 if (PyErr_Occurred()) SWIG_fail;
10366 }
10367 {
10368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10369 }
10370 {
10371 if (temp2)
10372 delete arg2;
10373 }
10374 return resultobj;
10375 fail:
10376 {
10377 if (temp2)
10378 delete arg2;
10379 }
10380 return NULL;
10381 }
10382
10383
10384 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10385 PyObject *resultobj = 0;
10386 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10387 wxFileSystem *arg2 = 0 ;
10388 wxString *arg3 = 0 ;
10389 wxFSFile *result = 0 ;
10390 void *argp1 = 0 ;
10391 int res1 = 0 ;
10392 void *argp2 = 0 ;
10393 int res2 = 0 ;
10394 bool temp3 = false ;
10395 PyObject * obj0 = 0 ;
10396 PyObject * obj1 = 0 ;
10397 PyObject * obj2 = 0 ;
10398 char * kwnames[] = {
10399 (char *) "self",(char *) "fs",(char *) "location", NULL
10400 };
10401
10402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10404 if (!SWIG_IsOK(res1)) {
10405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10406 }
10407 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10408 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10409 if (!SWIG_IsOK(res2)) {
10410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10411 }
10412 if (!argp2) {
10413 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10414 }
10415 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10416 {
10417 arg3 = wxString_in_helper(obj2);
10418 if (arg3 == NULL) SWIG_fail;
10419 temp3 = true;
10420 }
10421 {
10422 PyThreadState* __tstate = wxPyBeginAllowThreads();
10423 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10424 wxPyEndAllowThreads(__tstate);
10425 if (PyErr_Occurred()) SWIG_fail;
10426 }
10427 {
10428 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10429 }
10430 {
10431 if (temp3)
10432 delete arg3;
10433 }
10434 return resultobj;
10435 fail:
10436 {
10437 if (temp3)
10438 delete arg3;
10439 }
10440 return NULL;
10441 }
10442
10443
10444 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10445 PyObject *resultobj = 0;
10446 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10447 wxString *arg2 = 0 ;
10448 int arg3 = (int) 0 ;
10449 wxString result;
10450 void *argp1 = 0 ;
10451 int res1 = 0 ;
10452 bool temp2 = false ;
10453 int val3 ;
10454 int ecode3 = 0 ;
10455 PyObject * obj0 = 0 ;
10456 PyObject * obj1 = 0 ;
10457 PyObject * obj2 = 0 ;
10458 char * kwnames[] = {
10459 (char *) "self",(char *) "spec",(char *) "flags", NULL
10460 };
10461
10462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10464 if (!SWIG_IsOK(res1)) {
10465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10466 }
10467 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10468 {
10469 arg2 = wxString_in_helper(obj1);
10470 if (arg2 == NULL) SWIG_fail;
10471 temp2 = true;
10472 }
10473 if (obj2) {
10474 ecode3 = SWIG_AsVal_int(obj2, &val3);
10475 if (!SWIG_IsOK(ecode3)) {
10476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10477 }
10478 arg3 = static_cast< int >(val3);
10479 }
10480 {
10481 PyThreadState* __tstate = wxPyBeginAllowThreads();
10482 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10483 wxPyEndAllowThreads(__tstate);
10484 if (PyErr_Occurred()) SWIG_fail;
10485 }
10486 {
10487 #if wxUSE_UNICODE
10488 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10489 #else
10490 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10491 #endif
10492 }
10493 {
10494 if (temp2)
10495 delete arg2;
10496 }
10497 return resultobj;
10498 fail:
10499 {
10500 if (temp2)
10501 delete arg2;
10502 }
10503 return NULL;
10504 }
10505
10506
10507 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10508 PyObject *resultobj = 0;
10509 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10510 wxString result;
10511 void *argp1 = 0 ;
10512 int res1 = 0 ;
10513 PyObject *swig_obj[1] ;
10514
10515 if (!args) SWIG_fail;
10516 swig_obj[0] = args;
10517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10518 if (!SWIG_IsOK(res1)) {
10519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10520 }
10521 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10522 {
10523 PyThreadState* __tstate = wxPyBeginAllowThreads();
10524 result = (arg1)->FindNext();
10525 wxPyEndAllowThreads(__tstate);
10526 if (PyErr_Occurred()) SWIG_fail;
10527 }
10528 {
10529 #if wxUSE_UNICODE
10530 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10531 #else
10532 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10533 #endif
10534 }
10535 return resultobj;
10536 fail:
10537 return NULL;
10538 }
10539
10540
10541 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10542 PyObject *resultobj = 0;
10543 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10544 wxString *arg2 = 0 ;
10545 wxString result;
10546 void *argp1 = 0 ;
10547 int res1 = 0 ;
10548 bool temp2 = false ;
10549 PyObject * obj0 = 0 ;
10550 PyObject * obj1 = 0 ;
10551 char * kwnames[] = {
10552 (char *) "self",(char *) "location", NULL
10553 };
10554
10555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10557 if (!SWIG_IsOK(res1)) {
10558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10559 }
10560 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10561 {
10562 arg2 = wxString_in_helper(obj1);
10563 if (arg2 == NULL) SWIG_fail;
10564 temp2 = true;
10565 }
10566 {
10567 PyThreadState* __tstate = wxPyBeginAllowThreads();
10568 result = (arg1)->GetProtocol((wxString const &)*arg2);
10569 wxPyEndAllowThreads(__tstate);
10570 if (PyErr_Occurred()) SWIG_fail;
10571 }
10572 {
10573 #if wxUSE_UNICODE
10574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10575 #else
10576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10577 #endif
10578 }
10579 {
10580 if (temp2)
10581 delete arg2;
10582 }
10583 return resultobj;
10584 fail:
10585 {
10586 if (temp2)
10587 delete arg2;
10588 }
10589 return NULL;
10590 }
10591
10592
10593 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10594 PyObject *resultobj = 0;
10595 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10596 wxString *arg2 = 0 ;
10597 wxString result;
10598 void *argp1 = 0 ;
10599 int res1 = 0 ;
10600 bool temp2 = false ;
10601 PyObject * obj0 = 0 ;
10602 PyObject * obj1 = 0 ;
10603 char * kwnames[] = {
10604 (char *) "self",(char *) "location", NULL
10605 };
10606
10607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10609 if (!SWIG_IsOK(res1)) {
10610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10611 }
10612 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10613 {
10614 arg2 = wxString_in_helper(obj1);
10615 if (arg2 == NULL) SWIG_fail;
10616 temp2 = true;
10617 }
10618 {
10619 PyThreadState* __tstate = wxPyBeginAllowThreads();
10620 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10621 wxPyEndAllowThreads(__tstate);
10622 if (PyErr_Occurred()) SWIG_fail;
10623 }
10624 {
10625 #if wxUSE_UNICODE
10626 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10627 #else
10628 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10629 #endif
10630 }
10631 {
10632 if (temp2)
10633 delete arg2;
10634 }
10635 return resultobj;
10636 fail:
10637 {
10638 if (temp2)
10639 delete arg2;
10640 }
10641 return NULL;
10642 }
10643
10644
10645 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10646 PyObject *resultobj = 0;
10647 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10648 wxString *arg2 = 0 ;
10649 wxString result;
10650 void *argp1 = 0 ;
10651 int res1 = 0 ;
10652 bool temp2 = false ;
10653 PyObject * obj0 = 0 ;
10654 PyObject * obj1 = 0 ;
10655 char * kwnames[] = {
10656 (char *) "self",(char *) "location", NULL
10657 };
10658
10659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10661 if (!SWIG_IsOK(res1)) {
10662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10663 }
10664 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10665 {
10666 arg2 = wxString_in_helper(obj1);
10667 if (arg2 == NULL) SWIG_fail;
10668 temp2 = true;
10669 }
10670 {
10671 PyThreadState* __tstate = wxPyBeginAllowThreads();
10672 result = (arg1)->GetAnchor((wxString const &)*arg2);
10673 wxPyEndAllowThreads(__tstate);
10674 if (PyErr_Occurred()) SWIG_fail;
10675 }
10676 {
10677 #if wxUSE_UNICODE
10678 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10679 #else
10680 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10681 #endif
10682 }
10683 {
10684 if (temp2)
10685 delete arg2;
10686 }
10687 return resultobj;
10688 fail:
10689 {
10690 if (temp2)
10691 delete arg2;
10692 }
10693 return NULL;
10694 }
10695
10696
10697 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10698 PyObject *resultobj = 0;
10699 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10700 wxString *arg2 = 0 ;
10701 wxString result;
10702 void *argp1 = 0 ;
10703 int res1 = 0 ;
10704 bool temp2 = false ;
10705 PyObject * obj0 = 0 ;
10706 PyObject * obj1 = 0 ;
10707 char * kwnames[] = {
10708 (char *) "self",(char *) "location", NULL
10709 };
10710
10711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10713 if (!SWIG_IsOK(res1)) {
10714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10715 }
10716 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10717 {
10718 arg2 = wxString_in_helper(obj1);
10719 if (arg2 == NULL) SWIG_fail;
10720 temp2 = true;
10721 }
10722 {
10723 PyThreadState* __tstate = wxPyBeginAllowThreads();
10724 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10725 wxPyEndAllowThreads(__tstate);
10726 if (PyErr_Occurred()) SWIG_fail;
10727 }
10728 {
10729 #if wxUSE_UNICODE
10730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10731 #else
10732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10733 #endif
10734 }
10735 {
10736 if (temp2)
10737 delete arg2;
10738 }
10739 return resultobj;
10740 fail:
10741 {
10742 if (temp2)
10743 delete arg2;
10744 }
10745 return NULL;
10746 }
10747
10748
10749 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10750 PyObject *resultobj = 0;
10751 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10752 wxString *arg2 = 0 ;
10753 wxString result;
10754 void *argp1 = 0 ;
10755 int res1 = 0 ;
10756 bool temp2 = false ;
10757 PyObject * obj0 = 0 ;
10758 PyObject * obj1 = 0 ;
10759 char * kwnames[] = {
10760 (char *) "self",(char *) "location", NULL
10761 };
10762
10763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10765 if (!SWIG_IsOK(res1)) {
10766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10767 }
10768 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10769 {
10770 arg2 = wxString_in_helper(obj1);
10771 if (arg2 == NULL) SWIG_fail;
10772 temp2 = true;
10773 }
10774 {
10775 PyThreadState* __tstate = wxPyBeginAllowThreads();
10776 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10777 wxPyEndAllowThreads(__tstate);
10778 if (PyErr_Occurred()) SWIG_fail;
10779 }
10780 {
10781 #if wxUSE_UNICODE
10782 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10783 #else
10784 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10785 #endif
10786 }
10787 {
10788 if (temp2)
10789 delete arg2;
10790 }
10791 return resultobj;
10792 fail:
10793 {
10794 if (temp2)
10795 delete arg2;
10796 }
10797 return NULL;
10798 }
10799
10800
10801 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10802 PyObject *obj;
10803 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10804 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10805 return SWIG_Py_Void();
10806 }
10807
10808 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10809 return SWIG_Python_InitShadowInstance(args);
10810 }
10811
10812 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10813 PyObject *resultobj = 0;
10814 wxFileSystem *result = 0 ;
10815
10816 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10817 {
10818 PyThreadState* __tstate = wxPyBeginAllowThreads();
10819 result = (wxFileSystem *)new wxFileSystem();
10820 wxPyEndAllowThreads(__tstate);
10821 if (PyErr_Occurred()) SWIG_fail;
10822 }
10823 {
10824 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10825 }
10826 return resultobj;
10827 fail:
10828 return NULL;
10829 }
10830
10831
10832 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10833 PyObject *resultobj = 0;
10834 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10835 void *argp1 = 0 ;
10836 int res1 = 0 ;
10837 PyObject *swig_obj[1] ;
10838
10839 if (!args) SWIG_fail;
10840 swig_obj[0] = args;
10841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10842 if (!SWIG_IsOK(res1)) {
10843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10844 }
10845 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10846 {
10847 PyThreadState* __tstate = wxPyBeginAllowThreads();
10848 delete arg1;
10849
10850 wxPyEndAllowThreads(__tstate);
10851 if (PyErr_Occurred()) SWIG_fail;
10852 }
10853 resultobj = SWIG_Py_Void();
10854 return resultobj;
10855 fail:
10856 return NULL;
10857 }
10858
10859
10860 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10861 PyObject *resultobj = 0;
10862 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10863 wxString *arg2 = 0 ;
10864 bool arg3 = (bool) false ;
10865 void *argp1 = 0 ;
10866 int res1 = 0 ;
10867 bool temp2 = false ;
10868 bool val3 ;
10869 int ecode3 = 0 ;
10870 PyObject * obj0 = 0 ;
10871 PyObject * obj1 = 0 ;
10872 PyObject * obj2 = 0 ;
10873 char * kwnames[] = {
10874 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10875 };
10876
10877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10879 if (!SWIG_IsOK(res1)) {
10880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10881 }
10882 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10883 {
10884 arg2 = wxString_in_helper(obj1);
10885 if (arg2 == NULL) SWIG_fail;
10886 temp2 = true;
10887 }
10888 if (obj2) {
10889 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10890 if (!SWIG_IsOK(ecode3)) {
10891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10892 }
10893 arg3 = static_cast< bool >(val3);
10894 }
10895 {
10896 PyThreadState* __tstate = wxPyBeginAllowThreads();
10897 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10898 wxPyEndAllowThreads(__tstate);
10899 if (PyErr_Occurred()) SWIG_fail;
10900 }
10901 resultobj = SWIG_Py_Void();
10902 {
10903 if (temp2)
10904 delete arg2;
10905 }
10906 return resultobj;
10907 fail:
10908 {
10909 if (temp2)
10910 delete arg2;
10911 }
10912 return NULL;
10913 }
10914
10915
10916 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10917 PyObject *resultobj = 0;
10918 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10919 wxString result;
10920 void *argp1 = 0 ;
10921 int res1 = 0 ;
10922 PyObject *swig_obj[1] ;
10923
10924 if (!args) SWIG_fail;
10925 swig_obj[0] = args;
10926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10927 if (!SWIG_IsOK(res1)) {
10928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10929 }
10930 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10931 {
10932 PyThreadState* __tstate = wxPyBeginAllowThreads();
10933 result = (arg1)->GetPath();
10934 wxPyEndAllowThreads(__tstate);
10935 if (PyErr_Occurred()) SWIG_fail;
10936 }
10937 {
10938 #if wxUSE_UNICODE
10939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10940 #else
10941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10942 #endif
10943 }
10944 return resultobj;
10945 fail:
10946 return NULL;
10947 }
10948
10949
10950 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10951 PyObject *resultobj = 0;
10952 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10953 wxString *arg2 = 0 ;
10954 wxFSFile *result = 0 ;
10955 void *argp1 = 0 ;
10956 int res1 = 0 ;
10957 bool temp2 = false ;
10958 PyObject * obj0 = 0 ;
10959 PyObject * obj1 = 0 ;
10960 char * kwnames[] = {
10961 (char *) "self",(char *) "location", NULL
10962 };
10963
10964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10966 if (!SWIG_IsOK(res1)) {
10967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10968 }
10969 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10970 {
10971 arg2 = wxString_in_helper(obj1);
10972 if (arg2 == NULL) SWIG_fail;
10973 temp2 = true;
10974 }
10975 {
10976 PyThreadState* __tstate = wxPyBeginAllowThreads();
10977 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10978 wxPyEndAllowThreads(__tstate);
10979 if (PyErr_Occurred()) SWIG_fail;
10980 }
10981 {
10982 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10983 }
10984 {
10985 if (temp2)
10986 delete arg2;
10987 }
10988 return resultobj;
10989 fail:
10990 {
10991 if (temp2)
10992 delete arg2;
10993 }
10994 return NULL;
10995 }
10996
10997
10998 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10999 PyObject *resultobj = 0;
11000 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11001 wxString *arg2 = 0 ;
11002 int arg3 = (int) 0 ;
11003 wxString result;
11004 void *argp1 = 0 ;
11005 int res1 = 0 ;
11006 bool temp2 = false ;
11007 int val3 ;
11008 int ecode3 = 0 ;
11009 PyObject * obj0 = 0 ;
11010 PyObject * obj1 = 0 ;
11011 PyObject * obj2 = 0 ;
11012 char * kwnames[] = {
11013 (char *) "self",(char *) "spec",(char *) "flags", NULL
11014 };
11015
11016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11018 if (!SWIG_IsOK(res1)) {
11019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11020 }
11021 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11022 {
11023 arg2 = wxString_in_helper(obj1);
11024 if (arg2 == NULL) SWIG_fail;
11025 temp2 = true;
11026 }
11027 if (obj2) {
11028 ecode3 = SWIG_AsVal_int(obj2, &val3);
11029 if (!SWIG_IsOK(ecode3)) {
11030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
11031 }
11032 arg3 = static_cast< int >(val3);
11033 }
11034 {
11035 PyThreadState* __tstate = wxPyBeginAllowThreads();
11036 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11037 wxPyEndAllowThreads(__tstate);
11038 if (PyErr_Occurred()) SWIG_fail;
11039 }
11040 {
11041 #if wxUSE_UNICODE
11042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11043 #else
11044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11045 #endif
11046 }
11047 {
11048 if (temp2)
11049 delete arg2;
11050 }
11051 return resultobj;
11052 fail:
11053 {
11054 if (temp2)
11055 delete arg2;
11056 }
11057 return NULL;
11058 }
11059
11060
11061 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11062 PyObject *resultobj = 0;
11063 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11064 wxString result;
11065 void *argp1 = 0 ;
11066 int res1 = 0 ;
11067 PyObject *swig_obj[1] ;
11068
11069 if (!args) SWIG_fail;
11070 swig_obj[0] = args;
11071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11072 if (!SWIG_IsOK(res1)) {
11073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11074 }
11075 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11076 {
11077 PyThreadState* __tstate = wxPyBeginAllowThreads();
11078 result = (arg1)->FindNext();
11079 wxPyEndAllowThreads(__tstate);
11080 if (PyErr_Occurred()) SWIG_fail;
11081 }
11082 {
11083 #if wxUSE_UNICODE
11084 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11085 #else
11086 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11087 #endif
11088 }
11089 return resultobj;
11090 fail:
11091 return NULL;
11092 }
11093
11094
11095 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11096 PyObject *resultobj = 0;
11097 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11098 int res1 = 0 ;
11099 PyObject * obj0 = 0 ;
11100 char * kwnames[] = {
11101 (char *) "handler", NULL
11102 };
11103
11104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
11105 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
11106 if (!SWIG_IsOK(res1)) {
11107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11108 }
11109 {
11110 PyThreadState* __tstate = wxPyBeginAllowThreads();
11111 wxFileSystem::AddHandler(arg1);
11112 wxPyEndAllowThreads(__tstate);
11113 if (PyErr_Occurred()) SWIG_fail;
11114 }
11115 resultobj = SWIG_Py_Void();
11116 return resultobj;
11117 fail:
11118 return NULL;
11119 }
11120
11121
11122 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11123 PyObject *resultobj = 0;
11124 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11125 wxFileSystemHandler *result = 0 ;
11126 void *argp1 = 0 ;
11127 int res1 = 0 ;
11128 PyObject * obj0 = 0 ;
11129 char * kwnames[] = {
11130 (char *) "handler", NULL
11131 };
11132
11133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
11134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
11135 if (!SWIG_IsOK(res1)) {
11136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11137 }
11138 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
11139 {
11140 PyThreadState* __tstate = wxPyBeginAllowThreads();
11141 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
11142 wxPyEndAllowThreads(__tstate);
11143 if (PyErr_Occurred()) SWIG_fail;
11144 }
11145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
11146 return resultobj;
11147 fail:
11148 return NULL;
11149 }
11150
11151
11152 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11153 PyObject *resultobj = 0;
11154
11155 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
11156 {
11157 PyThreadState* __tstate = wxPyBeginAllowThreads();
11158 wxFileSystem::CleanUpHandlers();
11159 wxPyEndAllowThreads(__tstate);
11160 if (PyErr_Occurred()) SWIG_fail;
11161 }
11162 resultobj = SWIG_Py_Void();
11163 return resultobj;
11164 fail:
11165 return NULL;
11166 }
11167
11168
11169 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11170 PyObject *resultobj = 0;
11171 wxString *arg1 = 0 ;
11172 wxString result;
11173 bool temp1 = false ;
11174 PyObject * obj0 = 0 ;
11175 char * kwnames[] = {
11176 (char *) "filename", NULL
11177 };
11178
11179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
11180 {
11181 arg1 = wxString_in_helper(obj0);
11182 if (arg1 == NULL) SWIG_fail;
11183 temp1 = true;
11184 }
11185 {
11186 PyThreadState* __tstate = wxPyBeginAllowThreads();
11187 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
11188 wxPyEndAllowThreads(__tstate);
11189 if (PyErr_Occurred()) SWIG_fail;
11190 }
11191 {
11192 #if wxUSE_UNICODE
11193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11194 #else
11195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11196 #endif
11197 }
11198 {
11199 if (temp1)
11200 delete arg1;
11201 }
11202 return resultobj;
11203 fail:
11204 {
11205 if (temp1)
11206 delete arg1;
11207 }
11208 return NULL;
11209 }
11210
11211
11212 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11213 PyObject *resultobj = 0;
11214 wxString *arg1 = 0 ;
11215 wxString result;
11216 bool temp1 = false ;
11217 PyObject * obj0 = 0 ;
11218 char * kwnames[] = {
11219 (char *) "url", NULL
11220 };
11221
11222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11223 {
11224 arg1 = wxString_in_helper(obj0);
11225 if (arg1 == NULL) SWIG_fail;
11226 temp1 = true;
11227 }
11228 {
11229 PyThreadState* __tstate = wxPyBeginAllowThreads();
11230 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11231 wxPyEndAllowThreads(__tstate);
11232 if (PyErr_Occurred()) SWIG_fail;
11233 }
11234 {
11235 #if wxUSE_UNICODE
11236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11237 #else
11238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11239 #endif
11240 }
11241 {
11242 if (temp1)
11243 delete arg1;
11244 }
11245 return resultobj;
11246 fail:
11247 {
11248 if (temp1)
11249 delete arg1;
11250 }
11251 return NULL;
11252 }
11253
11254
11255 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11256 PyObject *obj;
11257 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11258 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11259 return SWIG_Py_Void();
11260 }
11261
11262 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11263 return SWIG_Python_InitShadowInstance(args);
11264 }
11265
11266 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11267 PyObject *resultobj = 0;
11268 wxInternetFSHandler *result = 0 ;
11269
11270 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11271 {
11272 PyThreadState* __tstate = wxPyBeginAllowThreads();
11273 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11274 wxPyEndAllowThreads(__tstate);
11275 if (PyErr_Occurred()) SWIG_fail;
11276 }
11277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11278 return resultobj;
11279 fail:
11280 return NULL;
11281 }
11282
11283
11284 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11285 PyObject *resultobj = 0;
11286 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11287 wxString *arg2 = 0 ;
11288 bool result;
11289 void *argp1 = 0 ;
11290 int res1 = 0 ;
11291 bool temp2 = false ;
11292 PyObject * obj0 = 0 ;
11293 PyObject * obj1 = 0 ;
11294 char * kwnames[] = {
11295 (char *) "self",(char *) "location", NULL
11296 };
11297
11298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11300 if (!SWIG_IsOK(res1)) {
11301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11302 }
11303 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11304 {
11305 arg2 = wxString_in_helper(obj1);
11306 if (arg2 == NULL) SWIG_fail;
11307 temp2 = true;
11308 }
11309 {
11310 PyThreadState* __tstate = wxPyBeginAllowThreads();
11311 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11312 wxPyEndAllowThreads(__tstate);
11313 if (PyErr_Occurred()) SWIG_fail;
11314 }
11315 {
11316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11317 }
11318 {
11319 if (temp2)
11320 delete arg2;
11321 }
11322 return resultobj;
11323 fail:
11324 {
11325 if (temp2)
11326 delete arg2;
11327 }
11328 return NULL;
11329 }
11330
11331
11332 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11333 PyObject *resultobj = 0;
11334 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11335 wxFileSystem *arg2 = 0 ;
11336 wxString *arg3 = 0 ;
11337 wxFSFile *result = 0 ;
11338 void *argp1 = 0 ;
11339 int res1 = 0 ;
11340 void *argp2 = 0 ;
11341 int res2 = 0 ;
11342 bool temp3 = false ;
11343 PyObject * obj0 = 0 ;
11344 PyObject * obj1 = 0 ;
11345 PyObject * obj2 = 0 ;
11346 char * kwnames[] = {
11347 (char *) "self",(char *) "fs",(char *) "location", NULL
11348 };
11349
11350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11352 if (!SWIG_IsOK(res1)) {
11353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11354 }
11355 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11356 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11357 if (!SWIG_IsOK(res2)) {
11358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11359 }
11360 if (!argp2) {
11361 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11362 }
11363 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11364 {
11365 arg3 = wxString_in_helper(obj2);
11366 if (arg3 == NULL) SWIG_fail;
11367 temp3 = true;
11368 }
11369 {
11370 PyThreadState* __tstate = wxPyBeginAllowThreads();
11371 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11372 wxPyEndAllowThreads(__tstate);
11373 if (PyErr_Occurred()) SWIG_fail;
11374 }
11375 {
11376 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11377 }
11378 {
11379 if (temp3)
11380 delete arg3;
11381 }
11382 return resultobj;
11383 fail:
11384 {
11385 if (temp3)
11386 delete arg3;
11387 }
11388 return NULL;
11389 }
11390
11391
11392 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11393 PyObject *obj;
11394 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11395 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11396 return SWIG_Py_Void();
11397 }
11398
11399 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11400 return SWIG_Python_InitShadowInstance(args);
11401 }
11402
11403 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11404 PyObject *resultobj = 0;
11405 wxZipFSHandler *result = 0 ;
11406
11407 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11408 {
11409 PyThreadState* __tstate = wxPyBeginAllowThreads();
11410 result = (wxZipFSHandler *)new wxZipFSHandler();
11411 wxPyEndAllowThreads(__tstate);
11412 if (PyErr_Occurred()) SWIG_fail;
11413 }
11414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11415 return resultobj;
11416 fail:
11417 return NULL;
11418 }
11419
11420
11421 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11422 PyObject *resultobj = 0;
11423 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11424 wxString *arg2 = 0 ;
11425 bool result;
11426 void *argp1 = 0 ;
11427 int res1 = 0 ;
11428 bool temp2 = false ;
11429 PyObject * obj0 = 0 ;
11430 PyObject * obj1 = 0 ;
11431 char * kwnames[] = {
11432 (char *) "self",(char *) "location", NULL
11433 };
11434
11435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11437 if (!SWIG_IsOK(res1)) {
11438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11439 }
11440 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11441 {
11442 arg2 = wxString_in_helper(obj1);
11443 if (arg2 == NULL) SWIG_fail;
11444 temp2 = true;
11445 }
11446 {
11447 PyThreadState* __tstate = wxPyBeginAllowThreads();
11448 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11449 wxPyEndAllowThreads(__tstate);
11450 if (PyErr_Occurred()) SWIG_fail;
11451 }
11452 {
11453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11454 }
11455 {
11456 if (temp2)
11457 delete arg2;
11458 }
11459 return resultobj;
11460 fail:
11461 {
11462 if (temp2)
11463 delete arg2;
11464 }
11465 return NULL;
11466 }
11467
11468
11469 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11470 PyObject *resultobj = 0;
11471 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11472 wxFileSystem *arg2 = 0 ;
11473 wxString *arg3 = 0 ;
11474 wxFSFile *result = 0 ;
11475 void *argp1 = 0 ;
11476 int res1 = 0 ;
11477 void *argp2 = 0 ;
11478 int res2 = 0 ;
11479 bool temp3 = false ;
11480 PyObject * obj0 = 0 ;
11481 PyObject * obj1 = 0 ;
11482 PyObject * obj2 = 0 ;
11483 char * kwnames[] = {
11484 (char *) "self",(char *) "fs",(char *) "location", NULL
11485 };
11486
11487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11489 if (!SWIG_IsOK(res1)) {
11490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11491 }
11492 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11493 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11494 if (!SWIG_IsOK(res2)) {
11495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11496 }
11497 if (!argp2) {
11498 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11499 }
11500 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11501 {
11502 arg3 = wxString_in_helper(obj2);
11503 if (arg3 == NULL) SWIG_fail;
11504 temp3 = true;
11505 }
11506 {
11507 PyThreadState* __tstate = wxPyBeginAllowThreads();
11508 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11509 wxPyEndAllowThreads(__tstate);
11510 if (PyErr_Occurred()) SWIG_fail;
11511 }
11512 {
11513 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11514 }
11515 {
11516 if (temp3)
11517 delete arg3;
11518 }
11519 return resultobj;
11520 fail:
11521 {
11522 if (temp3)
11523 delete arg3;
11524 }
11525 return NULL;
11526 }
11527
11528
11529 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11530 PyObject *resultobj = 0;
11531 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11532 wxString *arg2 = 0 ;
11533 int arg3 = (int) 0 ;
11534 wxString result;
11535 void *argp1 = 0 ;
11536 int res1 = 0 ;
11537 bool temp2 = false ;
11538 int val3 ;
11539 int ecode3 = 0 ;
11540 PyObject * obj0 = 0 ;
11541 PyObject * obj1 = 0 ;
11542 PyObject * obj2 = 0 ;
11543 char * kwnames[] = {
11544 (char *) "self",(char *) "spec",(char *) "flags", NULL
11545 };
11546
11547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11549 if (!SWIG_IsOK(res1)) {
11550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11551 }
11552 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11553 {
11554 arg2 = wxString_in_helper(obj1);
11555 if (arg2 == NULL) SWIG_fail;
11556 temp2 = true;
11557 }
11558 if (obj2) {
11559 ecode3 = SWIG_AsVal_int(obj2, &val3);
11560 if (!SWIG_IsOK(ecode3)) {
11561 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11562 }
11563 arg3 = static_cast< int >(val3);
11564 }
11565 {
11566 PyThreadState* __tstate = wxPyBeginAllowThreads();
11567 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11568 wxPyEndAllowThreads(__tstate);
11569 if (PyErr_Occurred()) SWIG_fail;
11570 }
11571 {
11572 #if wxUSE_UNICODE
11573 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11574 #else
11575 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11576 #endif
11577 }
11578 {
11579 if (temp2)
11580 delete arg2;
11581 }
11582 return resultobj;
11583 fail:
11584 {
11585 if (temp2)
11586 delete arg2;
11587 }
11588 return NULL;
11589 }
11590
11591
11592 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11593 PyObject *resultobj = 0;
11594 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11595 wxString result;
11596 void *argp1 = 0 ;
11597 int res1 = 0 ;
11598 PyObject *swig_obj[1] ;
11599
11600 if (!args) SWIG_fail;
11601 swig_obj[0] = args;
11602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11603 if (!SWIG_IsOK(res1)) {
11604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11605 }
11606 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11607 {
11608 PyThreadState* __tstate = wxPyBeginAllowThreads();
11609 result = (arg1)->FindNext();
11610 wxPyEndAllowThreads(__tstate);
11611 if (PyErr_Occurred()) SWIG_fail;
11612 }
11613 {
11614 #if wxUSE_UNICODE
11615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11616 #else
11617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11618 #endif
11619 }
11620 return resultobj;
11621 fail:
11622 return NULL;
11623 }
11624
11625
11626 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11627 PyObject *obj;
11628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11629 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11630 return SWIG_Py_Void();
11631 }
11632
11633 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11634 return SWIG_Python_InitShadowInstance(args);
11635 }
11636
11637 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11638 PyObject *resultobj = 0;
11639 wxString *arg1 = 0 ;
11640 wxImage *arg2 = 0 ;
11641 long arg3 ;
11642 bool temp1 = false ;
11643 void *argp2 = 0 ;
11644 int res2 = 0 ;
11645 long val3 ;
11646 int ecode3 = 0 ;
11647 PyObject * obj0 = 0 ;
11648 PyObject * obj1 = 0 ;
11649 PyObject * obj2 = 0 ;
11650 char * kwnames[] = {
11651 (char *) "filename",(char *) "image",(char *) "type", NULL
11652 };
11653
11654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11655 {
11656 arg1 = wxString_in_helper(obj0);
11657 if (arg1 == NULL) SWIG_fail;
11658 temp1 = true;
11659 }
11660 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11661 if (!SWIG_IsOK(res2)) {
11662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11663 }
11664 if (!argp2) {
11665 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11666 }
11667 arg2 = reinterpret_cast< wxImage * >(argp2);
11668 ecode3 = SWIG_AsVal_long(obj2, &val3);
11669 if (!SWIG_IsOK(ecode3)) {
11670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11671 }
11672 arg3 = static_cast< long >(val3);
11673 {
11674 PyThreadState* __tstate = wxPyBeginAllowThreads();
11675 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11676 wxPyEndAllowThreads(__tstate);
11677 if (PyErr_Occurred()) SWIG_fail;
11678 }
11679 resultobj = SWIG_Py_Void();
11680 {
11681 if (temp1)
11682 delete arg1;
11683 }
11684 return resultobj;
11685 fail:
11686 {
11687 if (temp1)
11688 delete arg1;
11689 }
11690 return NULL;
11691 }
11692
11693
11694 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11695 PyObject *resultobj = 0;
11696 wxString *arg1 = 0 ;
11697 wxBitmap *arg2 = 0 ;
11698 long arg3 ;
11699 bool temp1 = false ;
11700 void *argp2 = 0 ;
11701 int res2 = 0 ;
11702 long val3 ;
11703 int ecode3 = 0 ;
11704 PyObject * obj0 = 0 ;
11705 PyObject * obj1 = 0 ;
11706 PyObject * obj2 = 0 ;
11707 char * kwnames[] = {
11708 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11709 };
11710
11711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11712 {
11713 arg1 = wxString_in_helper(obj0);
11714 if (arg1 == NULL) SWIG_fail;
11715 temp1 = true;
11716 }
11717 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11718 if (!SWIG_IsOK(res2)) {
11719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11720 }
11721 if (!argp2) {
11722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11723 }
11724 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11725 ecode3 = SWIG_AsVal_long(obj2, &val3);
11726 if (!SWIG_IsOK(ecode3)) {
11727 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11728 }
11729 arg3 = static_cast< long >(val3);
11730 {
11731 PyThreadState* __tstate = wxPyBeginAllowThreads();
11732 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11733 wxPyEndAllowThreads(__tstate);
11734 if (PyErr_Occurred()) SWIG_fail;
11735 }
11736 resultobj = SWIG_Py_Void();
11737 {
11738 if (temp1)
11739 delete arg1;
11740 }
11741 return resultobj;
11742 fail:
11743 {
11744 if (temp1)
11745 delete arg1;
11746 }
11747 return NULL;
11748 }
11749
11750
11751 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11752 PyObject *resultobj = 0;
11753 wxString *arg1 = 0 ;
11754 PyObject *arg2 = (PyObject *) 0 ;
11755 bool temp1 = false ;
11756 PyObject * obj0 = 0 ;
11757 PyObject * obj1 = 0 ;
11758 char * kwnames[] = {
11759 (char *) "filename",(char *) "data", NULL
11760 };
11761
11762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11763 {
11764 arg1 = wxString_in_helper(obj0);
11765 if (arg1 == NULL) SWIG_fail;
11766 temp1 = true;
11767 }
11768 arg2 = obj1;
11769 {
11770 PyThreadState* __tstate = wxPyBeginAllowThreads();
11771 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11772 wxPyEndAllowThreads(__tstate);
11773 if (PyErr_Occurred()) SWIG_fail;
11774 }
11775 resultobj = SWIG_Py_Void();
11776 {
11777 if (temp1)
11778 delete arg1;
11779 }
11780 return resultobj;
11781 fail:
11782 {
11783 if (temp1)
11784 delete arg1;
11785 }
11786 return NULL;
11787 }
11788
11789
11790 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11791 PyObject *resultobj = 0;
11792 wxMemoryFSHandler *result = 0 ;
11793
11794 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11795 {
11796 PyThreadState* __tstate = wxPyBeginAllowThreads();
11797 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11798 wxPyEndAllowThreads(__tstate);
11799 if (PyErr_Occurred()) SWIG_fail;
11800 }
11801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11802 return resultobj;
11803 fail:
11804 return NULL;
11805 }
11806
11807
11808 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11809 PyObject *resultobj = 0;
11810 wxString *arg1 = 0 ;
11811 bool temp1 = false ;
11812 PyObject * obj0 = 0 ;
11813 char * kwnames[] = {
11814 (char *) "filename", NULL
11815 };
11816
11817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11818 {
11819 arg1 = wxString_in_helper(obj0);
11820 if (arg1 == NULL) SWIG_fail;
11821 temp1 = true;
11822 }
11823 {
11824 PyThreadState* __tstate = wxPyBeginAllowThreads();
11825 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11826 wxPyEndAllowThreads(__tstate);
11827 if (PyErr_Occurred()) SWIG_fail;
11828 }
11829 resultobj = SWIG_Py_Void();
11830 {
11831 if (temp1)
11832 delete arg1;
11833 }
11834 return resultobj;
11835 fail:
11836 {
11837 if (temp1)
11838 delete arg1;
11839 }
11840 return NULL;
11841 }
11842
11843
11844 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11845 PyObject *resultobj = 0;
11846 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11847 wxString *arg2 = 0 ;
11848 bool result;
11849 void *argp1 = 0 ;
11850 int res1 = 0 ;
11851 bool temp2 = false ;
11852 PyObject * obj0 = 0 ;
11853 PyObject * obj1 = 0 ;
11854 char * kwnames[] = {
11855 (char *) "self",(char *) "location", NULL
11856 };
11857
11858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11860 if (!SWIG_IsOK(res1)) {
11861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11862 }
11863 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11864 {
11865 arg2 = wxString_in_helper(obj1);
11866 if (arg2 == NULL) SWIG_fail;
11867 temp2 = true;
11868 }
11869 {
11870 PyThreadState* __tstate = wxPyBeginAllowThreads();
11871 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11872 wxPyEndAllowThreads(__tstate);
11873 if (PyErr_Occurred()) SWIG_fail;
11874 }
11875 {
11876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11877 }
11878 {
11879 if (temp2)
11880 delete arg2;
11881 }
11882 return resultobj;
11883 fail:
11884 {
11885 if (temp2)
11886 delete arg2;
11887 }
11888 return NULL;
11889 }
11890
11891
11892 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11893 PyObject *resultobj = 0;
11894 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11895 wxFileSystem *arg2 = 0 ;
11896 wxString *arg3 = 0 ;
11897 wxFSFile *result = 0 ;
11898 void *argp1 = 0 ;
11899 int res1 = 0 ;
11900 void *argp2 = 0 ;
11901 int res2 = 0 ;
11902 bool temp3 = false ;
11903 PyObject * obj0 = 0 ;
11904 PyObject * obj1 = 0 ;
11905 PyObject * obj2 = 0 ;
11906 char * kwnames[] = {
11907 (char *) "self",(char *) "fs",(char *) "location", NULL
11908 };
11909
11910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11912 if (!SWIG_IsOK(res1)) {
11913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11914 }
11915 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11916 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11917 if (!SWIG_IsOK(res2)) {
11918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11919 }
11920 if (!argp2) {
11921 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11922 }
11923 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11924 {
11925 arg3 = wxString_in_helper(obj2);
11926 if (arg3 == NULL) SWIG_fail;
11927 temp3 = true;
11928 }
11929 {
11930 PyThreadState* __tstate = wxPyBeginAllowThreads();
11931 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11932 wxPyEndAllowThreads(__tstate);
11933 if (PyErr_Occurred()) SWIG_fail;
11934 }
11935 {
11936 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11937 }
11938 {
11939 if (temp3)
11940 delete arg3;
11941 }
11942 return resultobj;
11943 fail:
11944 {
11945 if (temp3)
11946 delete arg3;
11947 }
11948 return NULL;
11949 }
11950
11951
11952 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11953 PyObject *resultobj = 0;
11954 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11955 wxString *arg2 = 0 ;
11956 int arg3 = (int) 0 ;
11957 wxString result;
11958 void *argp1 = 0 ;
11959 int res1 = 0 ;
11960 bool temp2 = false ;
11961 int val3 ;
11962 int ecode3 = 0 ;
11963 PyObject * obj0 = 0 ;
11964 PyObject * obj1 = 0 ;
11965 PyObject * obj2 = 0 ;
11966 char * kwnames[] = {
11967 (char *) "self",(char *) "spec",(char *) "flags", NULL
11968 };
11969
11970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11972 if (!SWIG_IsOK(res1)) {
11973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11974 }
11975 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11976 {
11977 arg2 = wxString_in_helper(obj1);
11978 if (arg2 == NULL) SWIG_fail;
11979 temp2 = true;
11980 }
11981 if (obj2) {
11982 ecode3 = SWIG_AsVal_int(obj2, &val3);
11983 if (!SWIG_IsOK(ecode3)) {
11984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11985 }
11986 arg3 = static_cast< int >(val3);
11987 }
11988 {
11989 PyThreadState* __tstate = wxPyBeginAllowThreads();
11990 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11991 wxPyEndAllowThreads(__tstate);
11992 if (PyErr_Occurred()) SWIG_fail;
11993 }
11994 {
11995 #if wxUSE_UNICODE
11996 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11997 #else
11998 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11999 #endif
12000 }
12001 {
12002 if (temp2)
12003 delete arg2;
12004 }
12005 return resultobj;
12006 fail:
12007 {
12008 if (temp2)
12009 delete arg2;
12010 }
12011 return NULL;
12012 }
12013
12014
12015 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12016 PyObject *resultobj = 0;
12017 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
12018 wxString result;
12019 void *argp1 = 0 ;
12020 int res1 = 0 ;
12021 PyObject *swig_obj[1] ;
12022
12023 if (!args) SWIG_fail;
12024 swig_obj[0] = args;
12025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12026 if (!SWIG_IsOK(res1)) {
12027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12028 }
12029 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12030 {
12031 PyThreadState* __tstate = wxPyBeginAllowThreads();
12032 result = (arg1)->FindNext();
12033 wxPyEndAllowThreads(__tstate);
12034 if (PyErr_Occurred()) SWIG_fail;
12035 }
12036 {
12037 #if wxUSE_UNICODE
12038 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12039 #else
12040 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12041 #endif
12042 }
12043 return resultobj;
12044 fail:
12045 return NULL;
12046 }
12047
12048
12049 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12050 PyObject *obj;
12051 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12052 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
12053 return SWIG_Py_Void();
12054 }
12055
12056 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12057 return SWIG_Python_InitShadowInstance(args);
12058 }
12059
12060 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12061 PyObject *resultobj = 0;
12062 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12063 wxString result;
12064 void *argp1 = 0 ;
12065 int res1 = 0 ;
12066 PyObject *swig_obj[1] ;
12067
12068 if (!args) SWIG_fail;
12069 swig_obj[0] = args;
12070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12071 if (!SWIG_IsOK(res1)) {
12072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12073 }
12074 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12075 {
12076 PyThreadState* __tstate = wxPyBeginAllowThreads();
12077 result = (arg1)->GetName();
12078 wxPyEndAllowThreads(__tstate);
12079 if (PyErr_Occurred()) SWIG_fail;
12080 }
12081 {
12082 #if wxUSE_UNICODE
12083 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12084 #else
12085 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12086 #endif
12087 }
12088 return resultobj;
12089 fail:
12090 return NULL;
12091 }
12092
12093
12094 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12095 PyObject *resultobj = 0;
12096 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12097 wxString result;
12098 void *argp1 = 0 ;
12099 int res1 = 0 ;
12100 PyObject *swig_obj[1] ;
12101
12102 if (!args) SWIG_fail;
12103 swig_obj[0] = args;
12104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12105 if (!SWIG_IsOK(res1)) {
12106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12107 }
12108 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12109 {
12110 PyThreadState* __tstate = wxPyBeginAllowThreads();
12111 result = (arg1)->GetExtension();
12112 wxPyEndAllowThreads(__tstate);
12113 if (PyErr_Occurred()) SWIG_fail;
12114 }
12115 {
12116 #if wxUSE_UNICODE
12117 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12118 #else
12119 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12120 #endif
12121 }
12122 return resultobj;
12123 fail:
12124 return NULL;
12125 }
12126
12127
12128 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12129 PyObject *resultobj = 0;
12130 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12131 long result;
12132 void *argp1 = 0 ;
12133 int res1 = 0 ;
12134 PyObject *swig_obj[1] ;
12135
12136 if (!args) SWIG_fail;
12137 swig_obj[0] = args;
12138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12139 if (!SWIG_IsOK(res1)) {
12140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12141 }
12142 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12143 {
12144 PyThreadState* __tstate = wxPyBeginAllowThreads();
12145 result = (long)(arg1)->GetType();
12146 wxPyEndAllowThreads(__tstate);
12147 if (PyErr_Occurred()) SWIG_fail;
12148 }
12149 resultobj = SWIG_From_long(static_cast< long >(result));
12150 return resultobj;
12151 fail:
12152 return NULL;
12153 }
12154
12155
12156 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12157 PyObject *resultobj = 0;
12158 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12159 wxString 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_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12169 }
12170 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12171 {
12172 PyThreadState* __tstate = wxPyBeginAllowThreads();
12173 result = (arg1)->GetMimeType();
12174 wxPyEndAllowThreads(__tstate);
12175 if (PyErr_Occurred()) SWIG_fail;
12176 }
12177 {
12178 #if wxUSE_UNICODE
12179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12180 #else
12181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12182 #endif
12183 }
12184 return resultobj;
12185 fail:
12186 return NULL;
12187 }
12188
12189
12190 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12191 PyObject *resultobj = 0;
12192 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12193 wxString *arg2 = 0 ;
12194 bool result;
12195 void *argp1 = 0 ;
12196 int res1 = 0 ;
12197 bool temp2 = false ;
12198 PyObject * obj0 = 0 ;
12199 PyObject * obj1 = 0 ;
12200 char * kwnames[] = {
12201 (char *) "self",(char *) "name", NULL
12202 };
12203
12204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
12205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12206 if (!SWIG_IsOK(res1)) {
12207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12208 }
12209 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12210 {
12211 arg2 = wxString_in_helper(obj1);
12212 if (arg2 == NULL) SWIG_fail;
12213 temp2 = true;
12214 }
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12218 wxPyEndAllowThreads(__tstate);
12219 if (PyErr_Occurred()) SWIG_fail;
12220 }
12221 {
12222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12223 }
12224 {
12225 if (temp2)
12226 delete arg2;
12227 }
12228 return resultobj;
12229 fail:
12230 {
12231 if (temp2)
12232 delete arg2;
12233 }
12234 return NULL;
12235 }
12236
12237
12238 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12239 PyObject *resultobj = 0;
12240 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12241 wxInputStream *arg2 = 0 ;
12242 bool result;
12243 void *argp1 = 0 ;
12244 int res1 = 0 ;
12245 wxPyInputStream *temp2 ;
12246 bool created2 ;
12247 PyObject * obj0 = 0 ;
12248 PyObject * obj1 = 0 ;
12249 char * kwnames[] = {
12250 (char *) "self",(char *) "stream", NULL
12251 };
12252
12253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12255 if (!SWIG_IsOK(res1)) {
12256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12257 }
12258 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12259 {
12260 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12261 arg2 = temp2->m_wxis;
12262 created2 = false;
12263 } else {
12264 PyErr_Clear(); // clear the failure of the wxPyConvert above
12265 arg2 = wxPyCBInputStream_create(obj1, false);
12266 if (arg2 == NULL) {
12267 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12268 SWIG_fail;
12269 }
12270 created2 = true;
12271 }
12272 }
12273 {
12274 PyThreadState* __tstate = wxPyBeginAllowThreads();
12275 result = (bool)(arg1)->CanRead(*arg2);
12276 wxPyEndAllowThreads(__tstate);
12277 if (PyErr_Occurred()) SWIG_fail;
12278 }
12279 {
12280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12281 }
12282 {
12283 if (created2) delete arg2;
12284 }
12285 return resultobj;
12286 fail:
12287 {
12288 if (created2) delete arg2;
12289 }
12290 return NULL;
12291 }
12292
12293
12294 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12295 PyObject *resultobj = 0;
12296 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12297 wxString *arg2 = 0 ;
12298 void *argp1 = 0 ;
12299 int res1 = 0 ;
12300 bool temp2 = false ;
12301 PyObject * obj0 = 0 ;
12302 PyObject * obj1 = 0 ;
12303 char * kwnames[] = {
12304 (char *) "self",(char *) "name", NULL
12305 };
12306
12307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12309 if (!SWIG_IsOK(res1)) {
12310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12311 }
12312 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12313 {
12314 arg2 = wxString_in_helper(obj1);
12315 if (arg2 == NULL) SWIG_fail;
12316 temp2 = true;
12317 }
12318 {
12319 PyThreadState* __tstate = wxPyBeginAllowThreads();
12320 (arg1)->SetName((wxString const &)*arg2);
12321 wxPyEndAllowThreads(__tstate);
12322 if (PyErr_Occurred()) SWIG_fail;
12323 }
12324 resultobj = SWIG_Py_Void();
12325 {
12326 if (temp2)
12327 delete arg2;
12328 }
12329 return resultobj;
12330 fail:
12331 {
12332 if (temp2)
12333 delete arg2;
12334 }
12335 return NULL;
12336 }
12337
12338
12339 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12340 PyObject *resultobj = 0;
12341 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12342 wxString *arg2 = 0 ;
12343 void *argp1 = 0 ;
12344 int res1 = 0 ;
12345 bool temp2 = false ;
12346 PyObject * obj0 = 0 ;
12347 PyObject * obj1 = 0 ;
12348 char * kwnames[] = {
12349 (char *) "self",(char *) "extension", NULL
12350 };
12351
12352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12354 if (!SWIG_IsOK(res1)) {
12355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12356 }
12357 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12358 {
12359 arg2 = wxString_in_helper(obj1);
12360 if (arg2 == NULL) SWIG_fail;
12361 temp2 = true;
12362 }
12363 {
12364 PyThreadState* __tstate = wxPyBeginAllowThreads();
12365 (arg1)->SetExtension((wxString const &)*arg2);
12366 wxPyEndAllowThreads(__tstate);
12367 if (PyErr_Occurred()) SWIG_fail;
12368 }
12369 resultobj = SWIG_Py_Void();
12370 {
12371 if (temp2)
12372 delete arg2;
12373 }
12374 return resultobj;
12375 fail:
12376 {
12377 if (temp2)
12378 delete arg2;
12379 }
12380 return NULL;
12381 }
12382
12383
12384 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12385 PyObject *resultobj = 0;
12386 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12387 long arg2 ;
12388 void *argp1 = 0 ;
12389 int res1 = 0 ;
12390 long val2 ;
12391 int ecode2 = 0 ;
12392 PyObject * obj0 = 0 ;
12393 PyObject * obj1 = 0 ;
12394 char * kwnames[] = {
12395 (char *) "self",(char *) "type", NULL
12396 };
12397
12398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12400 if (!SWIG_IsOK(res1)) {
12401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12402 }
12403 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12404 ecode2 = SWIG_AsVal_long(obj1, &val2);
12405 if (!SWIG_IsOK(ecode2)) {
12406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12407 }
12408 arg2 = static_cast< long >(val2);
12409 {
12410 PyThreadState* __tstate = wxPyBeginAllowThreads();
12411 (arg1)->SetType(arg2);
12412 wxPyEndAllowThreads(__tstate);
12413 if (PyErr_Occurred()) SWIG_fail;
12414 }
12415 resultobj = SWIG_Py_Void();
12416 return resultobj;
12417 fail:
12418 return NULL;
12419 }
12420
12421
12422 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12423 PyObject *resultobj = 0;
12424 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12425 wxString *arg2 = 0 ;
12426 void *argp1 = 0 ;
12427 int res1 = 0 ;
12428 bool temp2 = false ;
12429 PyObject * obj0 = 0 ;
12430 PyObject * obj1 = 0 ;
12431 char * kwnames[] = {
12432 (char *) "self",(char *) "mimetype", NULL
12433 };
12434
12435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12437 if (!SWIG_IsOK(res1)) {
12438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12439 }
12440 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12441 {
12442 arg2 = wxString_in_helper(obj1);
12443 if (arg2 == NULL) SWIG_fail;
12444 temp2 = true;
12445 }
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 (arg1)->SetMimeType((wxString const &)*arg2);
12449 wxPyEndAllowThreads(__tstate);
12450 if (PyErr_Occurred()) SWIG_fail;
12451 }
12452 resultobj = SWIG_Py_Void();
12453 {
12454 if (temp2)
12455 delete arg2;
12456 }
12457 return resultobj;
12458 fail:
12459 {
12460 if (temp2)
12461 delete arg2;
12462 }
12463 return NULL;
12464 }
12465
12466
12467 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12468 PyObject *obj;
12469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12470 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12471 return SWIG_Py_Void();
12472 }
12473
12474 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12475 PyObject *resultobj = 0;
12476 wxPyImageHandler *result = 0 ;
12477
12478 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12479 {
12480 PyThreadState* __tstate = wxPyBeginAllowThreads();
12481 result = (wxPyImageHandler *)new wxPyImageHandler();
12482 wxPyEndAllowThreads(__tstate);
12483 if (PyErr_Occurred()) SWIG_fail;
12484 }
12485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12486 return resultobj;
12487 fail:
12488 return NULL;
12489 }
12490
12491
12492 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12493 PyObject *resultobj = 0;
12494 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12495 PyObject *arg2 = (PyObject *) 0 ;
12496 void *argp1 = 0 ;
12497 int res1 = 0 ;
12498 PyObject * obj0 = 0 ;
12499 PyObject * obj1 = 0 ;
12500 char * kwnames[] = {
12501 (char *) "self",(char *) "self", NULL
12502 };
12503
12504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12506 if (!SWIG_IsOK(res1)) {
12507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12508 }
12509 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12510 arg2 = obj1;
12511 {
12512 PyThreadState* __tstate = wxPyBeginAllowThreads();
12513 (arg1)->_SetSelf(arg2);
12514 wxPyEndAllowThreads(__tstate);
12515 if (PyErr_Occurred()) SWIG_fail;
12516 }
12517 resultobj = SWIG_Py_Void();
12518 return resultobj;
12519 fail:
12520 return NULL;
12521 }
12522
12523
12524 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12525 PyObject *obj;
12526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12527 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12528 return SWIG_Py_Void();
12529 }
12530
12531 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12532 return SWIG_Python_InitShadowInstance(args);
12533 }
12534
12535 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12536 PyObject *resultobj = 0;
12537 wxImageHistogram *result = 0 ;
12538
12539 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12540 {
12541 PyThreadState* __tstate = wxPyBeginAllowThreads();
12542 result = (wxImageHistogram *)new wxImageHistogram();
12543 wxPyEndAllowThreads(__tstate);
12544 if (PyErr_Occurred()) SWIG_fail;
12545 }
12546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12547 return resultobj;
12548 fail:
12549 return NULL;
12550 }
12551
12552
12553 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12554 PyObject *resultobj = 0;
12555 byte arg1 ;
12556 byte arg2 ;
12557 byte arg3 ;
12558 unsigned long result;
12559 unsigned char val1 ;
12560 int ecode1 = 0 ;
12561 unsigned char val2 ;
12562 int ecode2 = 0 ;
12563 unsigned char val3 ;
12564 int ecode3 = 0 ;
12565 PyObject * obj0 = 0 ;
12566 PyObject * obj1 = 0 ;
12567 PyObject * obj2 = 0 ;
12568 char * kwnames[] = {
12569 (char *) "r",(char *) "g",(char *) "b", NULL
12570 };
12571
12572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12573 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12574 if (!SWIG_IsOK(ecode1)) {
12575 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12576 }
12577 arg1 = static_cast< byte >(val1);
12578 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12579 if (!SWIG_IsOK(ecode2)) {
12580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12581 }
12582 arg2 = static_cast< byte >(val2);
12583 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12584 if (!SWIG_IsOK(ecode3)) {
12585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12586 }
12587 arg3 = static_cast< byte >(val3);
12588 {
12589 PyThreadState* __tstate = wxPyBeginAllowThreads();
12590 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12591 wxPyEndAllowThreads(__tstate);
12592 if (PyErr_Occurred()) SWIG_fail;
12593 }
12594 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12595 return resultobj;
12596 fail:
12597 return NULL;
12598 }
12599
12600
12601 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12602 PyObject *resultobj = 0;
12603 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12604 byte *arg2 = (byte *) 0 ;
12605 byte *arg3 = (byte *) 0 ;
12606 byte *arg4 = (byte *) 0 ;
12607 byte arg5 = (byte) 1 ;
12608 byte arg6 = (byte) 0 ;
12609 byte arg7 = (byte) 0 ;
12610 bool result;
12611 void *argp1 = 0 ;
12612 int res1 = 0 ;
12613 byte temp2 ;
12614 int res2 = SWIG_TMPOBJ ;
12615 byte temp3 ;
12616 int res3 = SWIG_TMPOBJ ;
12617 byte temp4 ;
12618 int res4 = SWIG_TMPOBJ ;
12619 unsigned char val5 ;
12620 int ecode5 = 0 ;
12621 unsigned char val6 ;
12622 int ecode6 = 0 ;
12623 unsigned char val7 ;
12624 int ecode7 = 0 ;
12625 PyObject * obj0 = 0 ;
12626 PyObject * obj1 = 0 ;
12627 PyObject * obj2 = 0 ;
12628 PyObject * obj3 = 0 ;
12629 char * kwnames[] = {
12630 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12631 };
12632
12633 arg2 = &temp2;
12634 arg3 = &temp3;
12635 arg4 = &temp4;
12636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12638 if (!SWIG_IsOK(res1)) {
12639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12640 }
12641 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12642 if (obj1) {
12643 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12644 if (!SWIG_IsOK(ecode5)) {
12645 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12646 }
12647 arg5 = static_cast< byte >(val5);
12648 }
12649 if (obj2) {
12650 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12651 if (!SWIG_IsOK(ecode6)) {
12652 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12653 }
12654 arg6 = static_cast< byte >(val6);
12655 }
12656 if (obj3) {
12657 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12658 if (!SWIG_IsOK(ecode7)) {
12659 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12660 }
12661 arg7 = static_cast< byte >(val7);
12662 }
12663 {
12664 PyThreadState* __tstate = wxPyBeginAllowThreads();
12665 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12666 wxPyEndAllowThreads(__tstate);
12667 if (PyErr_Occurred()) SWIG_fail;
12668 }
12669 {
12670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12671 }
12672 if (SWIG_IsTmpObj(res2)) {
12673 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12674 } else {
12675 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12676 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12677 }
12678 if (SWIG_IsTmpObj(res3)) {
12679 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12680 } else {
12681 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12682 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12683 }
12684 if (SWIG_IsTmpObj(res4)) {
12685 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12686 } else {
12687 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12688 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12689 }
12690 return resultobj;
12691 fail:
12692 return NULL;
12693 }
12694
12695
12696 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12697 PyObject *resultobj = 0;
12698 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12699 unsigned long arg2 ;
12700 unsigned long result;
12701 void *argp1 = 0 ;
12702 int res1 = 0 ;
12703 unsigned long val2 ;
12704 int ecode2 = 0 ;
12705 PyObject * obj0 = 0 ;
12706 PyObject * obj1 = 0 ;
12707 char * kwnames[] = {
12708 (char *) "self",(char *) "key", NULL
12709 };
12710
12711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12713 if (!SWIG_IsOK(res1)) {
12714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12715 }
12716 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12717 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12718 if (!SWIG_IsOK(ecode2)) {
12719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12720 }
12721 arg2 = static_cast< unsigned long >(val2);
12722 {
12723 PyThreadState* __tstate = wxPyBeginAllowThreads();
12724 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12725 wxPyEndAllowThreads(__tstate);
12726 if (PyErr_Occurred()) SWIG_fail;
12727 }
12728 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12729 return resultobj;
12730 fail:
12731 return NULL;
12732 }
12733
12734
12735 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12736 PyObject *resultobj = 0;
12737 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12738 byte arg2 ;
12739 byte arg3 ;
12740 byte arg4 ;
12741 unsigned long result;
12742 void *argp1 = 0 ;
12743 int res1 = 0 ;
12744 unsigned char val2 ;
12745 int ecode2 = 0 ;
12746 unsigned char val3 ;
12747 int ecode3 = 0 ;
12748 unsigned char val4 ;
12749 int ecode4 = 0 ;
12750 PyObject * obj0 = 0 ;
12751 PyObject * obj1 = 0 ;
12752 PyObject * obj2 = 0 ;
12753 PyObject * obj3 = 0 ;
12754 char * kwnames[] = {
12755 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12756 };
12757
12758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12760 if (!SWIG_IsOK(res1)) {
12761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12762 }
12763 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12764 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12765 if (!SWIG_IsOK(ecode2)) {
12766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12767 }
12768 arg2 = static_cast< byte >(val2);
12769 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12770 if (!SWIG_IsOK(ecode3)) {
12771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12772 }
12773 arg3 = static_cast< byte >(val3);
12774 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12775 if (!SWIG_IsOK(ecode4)) {
12776 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12777 }
12778 arg4 = static_cast< byte >(val4);
12779 {
12780 PyThreadState* __tstate = wxPyBeginAllowThreads();
12781 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12782 wxPyEndAllowThreads(__tstate);
12783 if (PyErr_Occurred()) SWIG_fail;
12784 }
12785 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12786 return resultobj;
12787 fail:
12788 return NULL;
12789 }
12790
12791
12792 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12793 PyObject *resultobj = 0;
12794 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12795 wxColour *arg2 = 0 ;
12796 unsigned long result;
12797 void *argp1 = 0 ;
12798 int res1 = 0 ;
12799 wxColour temp2 ;
12800 PyObject * obj0 = 0 ;
12801 PyObject * obj1 = 0 ;
12802 char * kwnames[] = {
12803 (char *) "self",(char *) "colour", NULL
12804 };
12805
12806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12808 if (!SWIG_IsOK(res1)) {
12809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12810 }
12811 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12812 {
12813 arg2 = &temp2;
12814 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12815 }
12816 {
12817 PyThreadState* __tstate = wxPyBeginAllowThreads();
12818 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12819 wxPyEndAllowThreads(__tstate);
12820 if (PyErr_Occurred()) SWIG_fail;
12821 }
12822 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12823 return resultobj;
12824 fail:
12825 return NULL;
12826 }
12827
12828
12829 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12830 PyObject *obj;
12831 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12832 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12833 return SWIG_Py_Void();
12834 }
12835
12836 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12837 return SWIG_Python_InitShadowInstance(args);
12838 }
12839
12840 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12841 PyObject *resultobj = 0;
12842 byte arg1 = (byte) 0 ;
12843 byte arg2 = (byte) 0 ;
12844 byte arg3 = (byte) 0 ;
12845 wxImage_RGBValue *result = 0 ;
12846 unsigned char val1 ;
12847 int ecode1 = 0 ;
12848 unsigned char val2 ;
12849 int ecode2 = 0 ;
12850 unsigned char val3 ;
12851 int ecode3 = 0 ;
12852 PyObject * obj0 = 0 ;
12853 PyObject * obj1 = 0 ;
12854 PyObject * obj2 = 0 ;
12855 char * kwnames[] = {
12856 (char *) "r",(char *) "g",(char *) "b", NULL
12857 };
12858
12859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12860 if (obj0) {
12861 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12862 if (!SWIG_IsOK(ecode1)) {
12863 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12864 }
12865 arg1 = static_cast< byte >(val1);
12866 }
12867 if (obj1) {
12868 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12869 if (!SWIG_IsOK(ecode2)) {
12870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12871 }
12872 arg2 = static_cast< byte >(val2);
12873 }
12874 if (obj2) {
12875 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12876 if (!SWIG_IsOK(ecode3)) {
12877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12878 }
12879 arg3 = static_cast< byte >(val3);
12880 }
12881 {
12882 PyThreadState* __tstate = wxPyBeginAllowThreads();
12883 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12884 wxPyEndAllowThreads(__tstate);
12885 if (PyErr_Occurred()) SWIG_fail;
12886 }
12887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12888 return resultobj;
12889 fail:
12890 return NULL;
12891 }
12892
12893
12894 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12895 PyObject *resultobj = 0;
12896 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12897 byte arg2 ;
12898 void *argp1 = 0 ;
12899 int res1 = 0 ;
12900 unsigned char val2 ;
12901 int ecode2 = 0 ;
12902 PyObject *swig_obj[2] ;
12903
12904 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12906 if (!SWIG_IsOK(res1)) {
12907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12908 }
12909 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12910 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12911 if (!SWIG_IsOK(ecode2)) {
12912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12913 }
12914 arg2 = static_cast< byte >(val2);
12915 if (arg1) (arg1)->red = arg2;
12916
12917 resultobj = SWIG_Py_Void();
12918 return resultobj;
12919 fail:
12920 return NULL;
12921 }
12922
12923
12924 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12925 PyObject *resultobj = 0;
12926 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12927 byte result;
12928 void *argp1 = 0 ;
12929 int res1 = 0 ;
12930 PyObject *swig_obj[1] ;
12931
12932 if (!args) SWIG_fail;
12933 swig_obj[0] = args;
12934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12935 if (!SWIG_IsOK(res1)) {
12936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12937 }
12938 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12939 result = (byte) ((arg1)->red);
12940 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12941 return resultobj;
12942 fail:
12943 return NULL;
12944 }
12945
12946
12947 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12948 PyObject *resultobj = 0;
12949 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12950 byte arg2 ;
12951 void *argp1 = 0 ;
12952 int res1 = 0 ;
12953 unsigned char val2 ;
12954 int ecode2 = 0 ;
12955 PyObject *swig_obj[2] ;
12956
12957 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12959 if (!SWIG_IsOK(res1)) {
12960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12961 }
12962 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12963 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12964 if (!SWIG_IsOK(ecode2)) {
12965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12966 }
12967 arg2 = static_cast< byte >(val2);
12968 if (arg1) (arg1)->green = arg2;
12969
12970 resultobj = SWIG_Py_Void();
12971 return resultobj;
12972 fail:
12973 return NULL;
12974 }
12975
12976
12977 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12978 PyObject *resultobj = 0;
12979 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12980 byte result;
12981 void *argp1 = 0 ;
12982 int res1 = 0 ;
12983 PyObject *swig_obj[1] ;
12984
12985 if (!args) SWIG_fail;
12986 swig_obj[0] = args;
12987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12988 if (!SWIG_IsOK(res1)) {
12989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12990 }
12991 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12992 result = (byte) ((arg1)->green);
12993 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12994 return resultobj;
12995 fail:
12996 return NULL;
12997 }
12998
12999
13000 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13001 PyObject *resultobj = 0;
13002 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13003 byte arg2 ;
13004 void *argp1 = 0 ;
13005 int res1 = 0 ;
13006 unsigned char val2 ;
13007 int ecode2 = 0 ;
13008 PyObject *swig_obj[2] ;
13009
13010 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
13011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13012 if (!SWIG_IsOK(res1)) {
13013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13014 }
13015 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13016 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13017 if (!SWIG_IsOK(ecode2)) {
13018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
13019 }
13020 arg2 = static_cast< byte >(val2);
13021 if (arg1) (arg1)->blue = arg2;
13022
13023 resultobj = SWIG_Py_Void();
13024 return resultobj;
13025 fail:
13026 return NULL;
13027 }
13028
13029
13030 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13031 PyObject *resultobj = 0;
13032 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13033 byte result;
13034 void *argp1 = 0 ;
13035 int res1 = 0 ;
13036 PyObject *swig_obj[1] ;
13037
13038 if (!args) SWIG_fail;
13039 swig_obj[0] = args;
13040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13041 if (!SWIG_IsOK(res1)) {
13042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13043 }
13044 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13045 result = (byte) ((arg1)->blue);
13046 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13047 return resultobj;
13048 fail:
13049 return NULL;
13050 }
13051
13052
13053 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13054 PyObject *obj;
13055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13056 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
13057 return SWIG_Py_Void();
13058 }
13059
13060 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13061 return SWIG_Python_InitShadowInstance(args);
13062 }
13063
13064 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13065 PyObject *resultobj = 0;
13066 double arg1 = (double) 0.0 ;
13067 double arg2 = (double) 0.0 ;
13068 double arg3 = (double) 0.0 ;
13069 wxImage_HSVValue *result = 0 ;
13070 double val1 ;
13071 int ecode1 = 0 ;
13072 double val2 ;
13073 int ecode2 = 0 ;
13074 double val3 ;
13075 int ecode3 = 0 ;
13076 PyObject * obj0 = 0 ;
13077 PyObject * obj1 = 0 ;
13078 PyObject * obj2 = 0 ;
13079 char * kwnames[] = {
13080 (char *) "h",(char *) "s",(char *) "v", NULL
13081 };
13082
13083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13084 if (obj0) {
13085 ecode1 = SWIG_AsVal_double(obj0, &val1);
13086 if (!SWIG_IsOK(ecode1)) {
13087 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
13088 }
13089 arg1 = static_cast< double >(val1);
13090 }
13091 if (obj1) {
13092 ecode2 = SWIG_AsVal_double(obj1, &val2);
13093 if (!SWIG_IsOK(ecode2)) {
13094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
13095 }
13096 arg2 = static_cast< double >(val2);
13097 }
13098 if (obj2) {
13099 ecode3 = SWIG_AsVal_double(obj2, &val3);
13100 if (!SWIG_IsOK(ecode3)) {
13101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
13102 }
13103 arg3 = static_cast< double >(val3);
13104 }
13105 {
13106 PyThreadState* __tstate = wxPyBeginAllowThreads();
13107 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
13108 wxPyEndAllowThreads(__tstate);
13109 if (PyErr_Occurred()) SWIG_fail;
13110 }
13111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
13112 return resultobj;
13113 fail:
13114 return NULL;
13115 }
13116
13117
13118 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13119 PyObject *resultobj = 0;
13120 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13121 double arg2 ;
13122 void *argp1 = 0 ;
13123 int res1 = 0 ;
13124 double val2 ;
13125 int ecode2 = 0 ;
13126 PyObject *swig_obj[2] ;
13127
13128 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
13129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13130 if (!SWIG_IsOK(res1)) {
13131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13132 }
13133 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13134 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13135 if (!SWIG_IsOK(ecode2)) {
13136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
13137 }
13138 arg2 = static_cast< double >(val2);
13139 if (arg1) (arg1)->hue = arg2;
13140
13141 resultobj = SWIG_Py_Void();
13142 return resultobj;
13143 fail:
13144 return NULL;
13145 }
13146
13147
13148 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13149 PyObject *resultobj = 0;
13150 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13151 double result;
13152 void *argp1 = 0 ;
13153 int res1 = 0 ;
13154 PyObject *swig_obj[1] ;
13155
13156 if (!args) SWIG_fail;
13157 swig_obj[0] = args;
13158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13159 if (!SWIG_IsOK(res1)) {
13160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13161 }
13162 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13163 result = (double) ((arg1)->hue);
13164 resultobj = SWIG_From_double(static_cast< double >(result));
13165 return resultobj;
13166 fail:
13167 return NULL;
13168 }
13169
13170
13171 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13172 PyObject *resultobj = 0;
13173 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13174 double arg2 ;
13175 void *argp1 = 0 ;
13176 int res1 = 0 ;
13177 double val2 ;
13178 int ecode2 = 0 ;
13179 PyObject *swig_obj[2] ;
13180
13181 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
13182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13183 if (!SWIG_IsOK(res1)) {
13184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13185 }
13186 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13187 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13188 if (!SWIG_IsOK(ecode2)) {
13189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
13190 }
13191 arg2 = static_cast< double >(val2);
13192 if (arg1) (arg1)->saturation = arg2;
13193
13194 resultobj = SWIG_Py_Void();
13195 return resultobj;
13196 fail:
13197 return NULL;
13198 }
13199
13200
13201 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13202 PyObject *resultobj = 0;
13203 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13204 double result;
13205 void *argp1 = 0 ;
13206 int res1 = 0 ;
13207 PyObject *swig_obj[1] ;
13208
13209 if (!args) SWIG_fail;
13210 swig_obj[0] = args;
13211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13212 if (!SWIG_IsOK(res1)) {
13213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13214 }
13215 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13216 result = (double) ((arg1)->saturation);
13217 resultobj = SWIG_From_double(static_cast< double >(result));
13218 return resultobj;
13219 fail:
13220 return NULL;
13221 }
13222
13223
13224 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13225 PyObject *resultobj = 0;
13226 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13227 double arg2 ;
13228 void *argp1 = 0 ;
13229 int res1 = 0 ;
13230 double val2 ;
13231 int ecode2 = 0 ;
13232 PyObject *swig_obj[2] ;
13233
13234 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13236 if (!SWIG_IsOK(res1)) {
13237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13238 }
13239 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13240 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13241 if (!SWIG_IsOK(ecode2)) {
13242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13243 }
13244 arg2 = static_cast< double >(val2);
13245 if (arg1) (arg1)->value = arg2;
13246
13247 resultobj = SWIG_Py_Void();
13248 return resultobj;
13249 fail:
13250 return NULL;
13251 }
13252
13253
13254 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13255 PyObject *resultobj = 0;
13256 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13257 double result;
13258 void *argp1 = 0 ;
13259 int res1 = 0 ;
13260 PyObject *swig_obj[1] ;
13261
13262 if (!args) SWIG_fail;
13263 swig_obj[0] = args;
13264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13265 if (!SWIG_IsOK(res1)) {
13266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13267 }
13268 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13269 result = (double) ((arg1)->value);
13270 resultobj = SWIG_From_double(static_cast< double >(result));
13271 return resultobj;
13272 fail:
13273 return NULL;
13274 }
13275
13276
13277 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13278 PyObject *obj;
13279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13280 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13281 return SWIG_Py_Void();
13282 }
13283
13284 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13285 return SWIG_Python_InitShadowInstance(args);
13286 }
13287
13288 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13289 PyObject *resultobj = 0;
13290 wxString *arg1 = 0 ;
13291 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13292 int arg3 = (int) -1 ;
13293 wxImage *result = 0 ;
13294 bool temp1 = false ;
13295 long val2 ;
13296 int ecode2 = 0 ;
13297 int val3 ;
13298 int ecode3 = 0 ;
13299 PyObject * obj0 = 0 ;
13300 PyObject * obj1 = 0 ;
13301 PyObject * obj2 = 0 ;
13302 char * kwnames[] = {
13303 (char *) "name",(char *) "type",(char *) "index", NULL
13304 };
13305
13306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13307 {
13308 arg1 = wxString_in_helper(obj0);
13309 if (arg1 == NULL) SWIG_fail;
13310 temp1 = true;
13311 }
13312 if (obj1) {
13313 ecode2 = SWIG_AsVal_long(obj1, &val2);
13314 if (!SWIG_IsOK(ecode2)) {
13315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13316 }
13317 arg2 = static_cast< long >(val2);
13318 }
13319 if (obj2) {
13320 ecode3 = SWIG_AsVal_int(obj2, &val3);
13321 if (!SWIG_IsOK(ecode3)) {
13322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13323 }
13324 arg3 = static_cast< int >(val3);
13325 }
13326 {
13327 PyThreadState* __tstate = wxPyBeginAllowThreads();
13328 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13329 wxPyEndAllowThreads(__tstate);
13330 if (PyErr_Occurred()) SWIG_fail;
13331 }
13332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13333 {
13334 if (temp1)
13335 delete arg1;
13336 }
13337 return resultobj;
13338 fail:
13339 {
13340 if (temp1)
13341 delete arg1;
13342 }
13343 return NULL;
13344 }
13345
13346
13347 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13348 PyObject *resultobj = 0;
13349 wxImage *arg1 = (wxImage *) 0 ;
13350 void *argp1 = 0 ;
13351 int res1 = 0 ;
13352 PyObject *swig_obj[1] ;
13353
13354 if (!args) SWIG_fail;
13355 swig_obj[0] = args;
13356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13357 if (!SWIG_IsOK(res1)) {
13358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13359 }
13360 arg1 = reinterpret_cast< wxImage * >(argp1);
13361 {
13362 PyThreadState* __tstate = wxPyBeginAllowThreads();
13363 delete arg1;
13364
13365 wxPyEndAllowThreads(__tstate);
13366 if (PyErr_Occurred()) SWIG_fail;
13367 }
13368 resultobj = SWIG_Py_Void();
13369 return resultobj;
13370 fail:
13371 return NULL;
13372 }
13373
13374
13375 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13376 PyObject *resultobj = 0;
13377 wxString *arg1 = 0 ;
13378 wxString *arg2 = 0 ;
13379 int arg3 = (int) -1 ;
13380 wxImage *result = 0 ;
13381 bool temp1 = false ;
13382 bool temp2 = false ;
13383 int val3 ;
13384 int ecode3 = 0 ;
13385 PyObject * obj0 = 0 ;
13386 PyObject * obj1 = 0 ;
13387 PyObject * obj2 = 0 ;
13388 char * kwnames[] = {
13389 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13390 };
13391
13392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13393 {
13394 arg1 = wxString_in_helper(obj0);
13395 if (arg1 == NULL) SWIG_fail;
13396 temp1 = true;
13397 }
13398 {
13399 arg2 = wxString_in_helper(obj1);
13400 if (arg2 == NULL) SWIG_fail;
13401 temp2 = true;
13402 }
13403 if (obj2) {
13404 ecode3 = SWIG_AsVal_int(obj2, &val3);
13405 if (!SWIG_IsOK(ecode3)) {
13406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13407 }
13408 arg3 = static_cast< int >(val3);
13409 }
13410 {
13411 PyThreadState* __tstate = wxPyBeginAllowThreads();
13412 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13413 wxPyEndAllowThreads(__tstate);
13414 if (PyErr_Occurred()) SWIG_fail;
13415 }
13416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13417 {
13418 if (temp1)
13419 delete arg1;
13420 }
13421 {
13422 if (temp2)
13423 delete arg2;
13424 }
13425 return resultobj;
13426 fail:
13427 {
13428 if (temp1)
13429 delete arg1;
13430 }
13431 {
13432 if (temp2)
13433 delete arg2;
13434 }
13435 return NULL;
13436 }
13437
13438
13439 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13440 PyObject *resultobj = 0;
13441 wxInputStream *arg1 = 0 ;
13442 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13443 int arg3 = (int) -1 ;
13444 wxImage *result = 0 ;
13445 wxPyInputStream *temp1 ;
13446 bool created1 ;
13447 long val2 ;
13448 int ecode2 = 0 ;
13449 int val3 ;
13450 int ecode3 = 0 ;
13451 PyObject * obj0 = 0 ;
13452 PyObject * obj1 = 0 ;
13453 PyObject * obj2 = 0 ;
13454 char * kwnames[] = {
13455 (char *) "stream",(char *) "type",(char *) "index", NULL
13456 };
13457
13458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13459 {
13460 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13461 arg1 = temp1->m_wxis;
13462 created1 = false;
13463 } else {
13464 PyErr_Clear(); // clear the failure of the wxPyConvert above
13465 arg1 = wxPyCBInputStream_create(obj0, false);
13466 if (arg1 == NULL) {
13467 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13468 SWIG_fail;
13469 }
13470 created1 = true;
13471 }
13472 }
13473 if (obj1) {
13474 ecode2 = SWIG_AsVal_long(obj1, &val2);
13475 if (!SWIG_IsOK(ecode2)) {
13476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13477 }
13478 arg2 = static_cast< long >(val2);
13479 }
13480 if (obj2) {
13481 ecode3 = SWIG_AsVal_int(obj2, &val3);
13482 if (!SWIG_IsOK(ecode3)) {
13483 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13484 }
13485 arg3 = static_cast< int >(val3);
13486 }
13487 {
13488 PyThreadState* __tstate = wxPyBeginAllowThreads();
13489 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13490 wxPyEndAllowThreads(__tstate);
13491 if (PyErr_Occurred()) SWIG_fail;
13492 }
13493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13494 {
13495 if (created1) delete arg1;
13496 }
13497 return resultobj;
13498 fail:
13499 {
13500 if (created1) delete arg1;
13501 }
13502 return NULL;
13503 }
13504
13505
13506 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13507 PyObject *resultobj = 0;
13508 wxInputStream *arg1 = 0 ;
13509 wxString *arg2 = 0 ;
13510 int arg3 = (int) -1 ;
13511 wxImage *result = 0 ;
13512 wxPyInputStream *temp1 ;
13513 bool created1 ;
13514 bool temp2 = false ;
13515 int val3 ;
13516 int ecode3 = 0 ;
13517 PyObject * obj0 = 0 ;
13518 PyObject * obj1 = 0 ;
13519 PyObject * obj2 = 0 ;
13520 char * kwnames[] = {
13521 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13522 };
13523
13524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13525 {
13526 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13527 arg1 = temp1->m_wxis;
13528 created1 = false;
13529 } else {
13530 PyErr_Clear(); // clear the failure of the wxPyConvert above
13531 arg1 = wxPyCBInputStream_create(obj0, false);
13532 if (arg1 == NULL) {
13533 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13534 SWIG_fail;
13535 }
13536 created1 = true;
13537 }
13538 }
13539 {
13540 arg2 = wxString_in_helper(obj1);
13541 if (arg2 == NULL) SWIG_fail;
13542 temp2 = true;
13543 }
13544 if (obj2) {
13545 ecode3 = SWIG_AsVal_int(obj2, &val3);
13546 if (!SWIG_IsOK(ecode3)) {
13547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13548 }
13549 arg3 = static_cast< int >(val3);
13550 }
13551 {
13552 PyThreadState* __tstate = wxPyBeginAllowThreads();
13553 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13554 wxPyEndAllowThreads(__tstate);
13555 if (PyErr_Occurred()) SWIG_fail;
13556 }
13557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13558 {
13559 if (created1) delete arg1;
13560 }
13561 {
13562 if (temp2)
13563 delete arg2;
13564 }
13565 return resultobj;
13566 fail:
13567 {
13568 if (created1) delete arg1;
13569 }
13570 {
13571 if (temp2)
13572 delete arg2;
13573 }
13574 return NULL;
13575 }
13576
13577
13578 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13579 PyObject *resultobj = 0;
13580 int arg1 = (int) 0 ;
13581 int arg2 = (int) 0 ;
13582 bool arg3 = (bool) true ;
13583 wxImage *result = 0 ;
13584 int val1 ;
13585 int ecode1 = 0 ;
13586 int val2 ;
13587 int ecode2 = 0 ;
13588 bool val3 ;
13589 int ecode3 = 0 ;
13590 PyObject * obj0 = 0 ;
13591 PyObject * obj1 = 0 ;
13592 PyObject * obj2 = 0 ;
13593 char * kwnames[] = {
13594 (char *) "width",(char *) "height",(char *) "clear", NULL
13595 };
13596
13597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13598 if (obj0) {
13599 ecode1 = SWIG_AsVal_int(obj0, &val1);
13600 if (!SWIG_IsOK(ecode1)) {
13601 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13602 }
13603 arg1 = static_cast< int >(val1);
13604 }
13605 if (obj1) {
13606 ecode2 = SWIG_AsVal_int(obj1, &val2);
13607 if (!SWIG_IsOK(ecode2)) {
13608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13609 }
13610 arg2 = static_cast< int >(val2);
13611 }
13612 if (obj2) {
13613 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13614 if (!SWIG_IsOK(ecode3)) {
13615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13616 }
13617 arg3 = static_cast< bool >(val3);
13618 }
13619 {
13620 PyThreadState* __tstate = wxPyBeginAllowThreads();
13621 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13622 wxPyEndAllowThreads(__tstate);
13623 if (PyErr_Occurred()) SWIG_fail;
13624 }
13625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13626 return resultobj;
13627 fail:
13628 return NULL;
13629 }
13630
13631
13632 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13633 PyObject *resultobj = 0;
13634 wxBitmap *arg1 = 0 ;
13635 wxImage *result = 0 ;
13636 void *argp1 = 0 ;
13637 int res1 = 0 ;
13638 PyObject * obj0 = 0 ;
13639 char * kwnames[] = {
13640 (char *) "bitmap", NULL
13641 };
13642
13643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13644 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13645 if (!SWIG_IsOK(res1)) {
13646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13647 }
13648 if (!argp1) {
13649 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13650 }
13651 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13652 {
13653 if (!wxPyCheckForApp()) SWIG_fail;
13654 PyThreadState* __tstate = wxPyBeginAllowThreads();
13655 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13656 wxPyEndAllowThreads(__tstate);
13657 if (PyErr_Occurred()) SWIG_fail;
13658 }
13659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13660 return resultobj;
13661 fail:
13662 return NULL;
13663 }
13664
13665
13666 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13667 PyObject *resultobj = 0;
13668 int arg1 ;
13669 int arg2 ;
13670 buffer arg3 ;
13671 int arg4 ;
13672 wxImage *result = 0 ;
13673 int val1 ;
13674 int ecode1 = 0 ;
13675 int val2 ;
13676 int ecode2 = 0 ;
13677 Py_ssize_t temp3 ;
13678 PyObject * obj0 = 0 ;
13679 PyObject * obj1 = 0 ;
13680 PyObject * obj2 = 0 ;
13681 char * kwnames[] = {
13682 (char *) "width",(char *) "height",(char *) "data", NULL
13683 };
13684
13685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13686 ecode1 = SWIG_AsVal_int(obj0, &val1);
13687 if (!SWIG_IsOK(ecode1)) {
13688 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13689 }
13690 arg1 = static_cast< int >(val1);
13691 ecode2 = SWIG_AsVal_int(obj1, &val2);
13692 if (!SWIG_IsOK(ecode2)) {
13693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13694 }
13695 arg2 = static_cast< int >(val2);
13696 {
13697 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13698 arg4 = (int)temp3;
13699 }
13700 {
13701 PyThreadState* __tstate = wxPyBeginAllowThreads();
13702 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13703 wxPyEndAllowThreads(__tstate);
13704 if (PyErr_Occurred()) SWIG_fail;
13705 }
13706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13707 return resultobj;
13708 fail:
13709 return NULL;
13710 }
13711
13712
13713 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13714 PyObject *resultobj = 0;
13715 int arg1 ;
13716 int arg2 ;
13717 buffer arg3 ;
13718 int arg4 ;
13719 buffer arg5 ;
13720 int arg6 ;
13721 wxImage *result = 0 ;
13722 int val1 ;
13723 int ecode1 = 0 ;
13724 int val2 ;
13725 int ecode2 = 0 ;
13726 Py_ssize_t temp3 ;
13727 Py_ssize_t temp5 ;
13728 PyObject * obj0 = 0 ;
13729 PyObject * obj1 = 0 ;
13730 PyObject * obj2 = 0 ;
13731 PyObject * obj3 = 0 ;
13732 char * kwnames[] = {
13733 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13734 };
13735
13736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13737 ecode1 = SWIG_AsVal_int(obj0, &val1);
13738 if (!SWIG_IsOK(ecode1)) {
13739 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13740 }
13741 arg1 = static_cast< int >(val1);
13742 ecode2 = SWIG_AsVal_int(obj1, &val2);
13743 if (!SWIG_IsOK(ecode2)) {
13744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13745 }
13746 arg2 = static_cast< int >(val2);
13747 {
13748 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13749 arg4 = (int)temp3;
13750 }
13751 {
13752 if (obj3 != Py_None) {
13753 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13754 arg6 = (int)temp5;
13755 }
13756 }
13757 {
13758 PyThreadState* __tstate = wxPyBeginAllowThreads();
13759 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13760 wxPyEndAllowThreads(__tstate);
13761 if (PyErr_Occurred()) SWIG_fail;
13762 }
13763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13764 return resultobj;
13765 fail:
13766 return NULL;
13767 }
13768
13769
13770 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13771 PyObject *resultobj = 0;
13772 wxImage *arg1 = (wxImage *) 0 ;
13773 int arg2 ;
13774 int arg3 ;
13775 bool arg4 = (bool) true ;
13776 void *argp1 = 0 ;
13777 int res1 = 0 ;
13778 int val2 ;
13779 int ecode2 = 0 ;
13780 int val3 ;
13781 int ecode3 = 0 ;
13782 bool val4 ;
13783 int ecode4 = 0 ;
13784 PyObject * obj0 = 0 ;
13785 PyObject * obj1 = 0 ;
13786 PyObject * obj2 = 0 ;
13787 PyObject * obj3 = 0 ;
13788 char * kwnames[] = {
13789 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13790 };
13791
13792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13794 if (!SWIG_IsOK(res1)) {
13795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13796 }
13797 arg1 = reinterpret_cast< wxImage * >(argp1);
13798 ecode2 = SWIG_AsVal_int(obj1, &val2);
13799 if (!SWIG_IsOK(ecode2)) {
13800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13801 }
13802 arg2 = static_cast< int >(val2);
13803 ecode3 = SWIG_AsVal_int(obj2, &val3);
13804 if (!SWIG_IsOK(ecode3)) {
13805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13806 }
13807 arg3 = static_cast< int >(val3);
13808 if (obj3) {
13809 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13810 if (!SWIG_IsOK(ecode4)) {
13811 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13812 }
13813 arg4 = static_cast< bool >(val4);
13814 }
13815 {
13816 PyThreadState* __tstate = wxPyBeginAllowThreads();
13817 (arg1)->Create(arg2,arg3,arg4);
13818 wxPyEndAllowThreads(__tstate);
13819 if (PyErr_Occurred()) SWIG_fail;
13820 }
13821 resultobj = SWIG_Py_Void();
13822 return resultobj;
13823 fail:
13824 return NULL;
13825 }
13826
13827
13828 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13829 PyObject *resultobj = 0;
13830 wxImage *arg1 = (wxImage *) 0 ;
13831 void *argp1 = 0 ;
13832 int res1 = 0 ;
13833 PyObject *swig_obj[1] ;
13834
13835 if (!args) SWIG_fail;
13836 swig_obj[0] = args;
13837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13838 if (!SWIG_IsOK(res1)) {
13839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13840 }
13841 arg1 = reinterpret_cast< wxImage * >(argp1);
13842 {
13843 PyThreadState* __tstate = wxPyBeginAllowThreads();
13844 (arg1)->Destroy();
13845 wxPyEndAllowThreads(__tstate);
13846 if (PyErr_Occurred()) SWIG_fail;
13847 }
13848 resultobj = SWIG_Py_Void();
13849 return resultobj;
13850 fail:
13851 return NULL;
13852 }
13853
13854
13855 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13856 PyObject *resultobj = 0;
13857 wxImage *arg1 = (wxImage *) 0 ;
13858 int arg2 ;
13859 int arg3 ;
13860 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
13861 SwigValueWrapper<wxImage > result;
13862 void *argp1 = 0 ;
13863 int res1 = 0 ;
13864 int val2 ;
13865 int ecode2 = 0 ;
13866 int val3 ;
13867 int ecode3 = 0 ;
13868 int val4 ;
13869 int ecode4 = 0 ;
13870 PyObject * obj0 = 0 ;
13871 PyObject * obj1 = 0 ;
13872 PyObject * obj2 = 0 ;
13873 PyObject * obj3 = 0 ;
13874 char * kwnames[] = {
13875 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
13876 };
13877
13878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13880 if (!SWIG_IsOK(res1)) {
13881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13882 }
13883 arg1 = reinterpret_cast< wxImage * >(argp1);
13884 ecode2 = SWIG_AsVal_int(obj1, &val2);
13885 if (!SWIG_IsOK(ecode2)) {
13886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13887 }
13888 arg2 = static_cast< int >(val2);
13889 ecode3 = SWIG_AsVal_int(obj2, &val3);
13890 if (!SWIG_IsOK(ecode3)) {
13891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13892 }
13893 arg3 = static_cast< int >(val3);
13894 if (obj3) {
13895 ecode4 = SWIG_AsVal_int(obj3, &val4);
13896 if (!SWIG_IsOK(ecode4)) {
13897 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
13898 }
13899 arg4 = static_cast< int >(val4);
13900 }
13901 {
13902 PyThreadState* __tstate = wxPyBeginAllowThreads();
13903 result = (arg1)->Scale(arg2,arg3,arg4);
13904 wxPyEndAllowThreads(__tstate);
13905 if (PyErr_Occurred()) SWIG_fail;
13906 }
13907 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13908 return resultobj;
13909 fail:
13910 return NULL;
13911 }
13912
13913
13914 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13915 PyObject *resultobj = 0;
13916 wxImage *arg1 = (wxImage *) 0 ;
13917 int arg2 ;
13918 int arg3 ;
13919 SwigValueWrapper<wxImage > result;
13920 void *argp1 = 0 ;
13921 int res1 = 0 ;
13922 int val2 ;
13923 int ecode2 = 0 ;
13924 int val3 ;
13925 int ecode3 = 0 ;
13926 PyObject * obj0 = 0 ;
13927 PyObject * obj1 = 0 ;
13928 PyObject * obj2 = 0 ;
13929 char * kwnames[] = {
13930 (char *) "self",(char *) "width",(char *) "height", NULL
13931 };
13932
13933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13935 if (!SWIG_IsOK(res1)) {
13936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
13937 }
13938 arg1 = reinterpret_cast< wxImage * >(argp1);
13939 ecode2 = SWIG_AsVal_int(obj1, &val2);
13940 if (!SWIG_IsOK(ecode2)) {
13941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
13942 }
13943 arg2 = static_cast< int >(val2);
13944 ecode3 = SWIG_AsVal_int(obj2, &val3);
13945 if (!SWIG_IsOK(ecode3)) {
13946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
13947 }
13948 arg3 = static_cast< int >(val3);
13949 {
13950 PyThreadState* __tstate = wxPyBeginAllowThreads();
13951 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
13952 wxPyEndAllowThreads(__tstate);
13953 if (PyErr_Occurred()) SWIG_fail;
13954 }
13955 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13956 return resultobj;
13957 fail:
13958 return NULL;
13959 }
13960
13961
13962 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13963 PyObject *resultobj = 0;
13964 wxImage *arg1 = (wxImage *) 0 ;
13965 int arg2 ;
13966 int arg3 ;
13967 SwigValueWrapper<wxImage > result;
13968 void *argp1 = 0 ;
13969 int res1 = 0 ;
13970 int val2 ;
13971 int ecode2 = 0 ;
13972 int val3 ;
13973 int ecode3 = 0 ;
13974 PyObject * obj0 = 0 ;
13975 PyObject * obj1 = 0 ;
13976 PyObject * obj2 = 0 ;
13977 char * kwnames[] = {
13978 (char *) "self",(char *) "width",(char *) "height", NULL
13979 };
13980
13981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13983 if (!SWIG_IsOK(res1)) {
13984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
13985 }
13986 arg1 = reinterpret_cast< wxImage * >(argp1);
13987 ecode2 = SWIG_AsVal_int(obj1, &val2);
13988 if (!SWIG_IsOK(ecode2)) {
13989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
13990 }
13991 arg2 = static_cast< int >(val2);
13992 ecode3 = SWIG_AsVal_int(obj2, &val3);
13993 if (!SWIG_IsOK(ecode3)) {
13994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
13995 }
13996 arg3 = static_cast< int >(val3);
13997 {
13998 PyThreadState* __tstate = wxPyBeginAllowThreads();
13999 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
14000 wxPyEndAllowThreads(__tstate);
14001 if (PyErr_Occurred()) SWIG_fail;
14002 }
14003 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14004 return resultobj;
14005 fail:
14006 return NULL;
14007 }
14008
14009
14010 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14011 PyObject *resultobj = 0;
14012 wxImage *arg1 = (wxImage *) 0 ;
14013 int arg2 ;
14014 SwigValueWrapper<wxImage > result;
14015 void *argp1 = 0 ;
14016 int res1 = 0 ;
14017 int val2 ;
14018 int ecode2 = 0 ;
14019 PyObject * obj0 = 0 ;
14020 PyObject * obj1 = 0 ;
14021 char * kwnames[] = {
14022 (char *) "self",(char *) "radius", NULL
14023 };
14024
14025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
14026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14027 if (!SWIG_IsOK(res1)) {
14028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
14029 }
14030 arg1 = reinterpret_cast< wxImage * >(argp1);
14031 ecode2 = SWIG_AsVal_int(obj1, &val2);
14032 if (!SWIG_IsOK(ecode2)) {
14033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
14034 }
14035 arg2 = static_cast< int >(val2);
14036 {
14037 PyThreadState* __tstate = wxPyBeginAllowThreads();
14038 result = (arg1)->Blur(arg2);
14039 wxPyEndAllowThreads(__tstate);
14040 if (PyErr_Occurred()) SWIG_fail;
14041 }
14042 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14043 return resultobj;
14044 fail:
14045 return NULL;
14046 }
14047
14048
14049 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14050 PyObject *resultobj = 0;
14051 wxImage *arg1 = (wxImage *) 0 ;
14052 int arg2 ;
14053 SwigValueWrapper<wxImage > result;
14054 void *argp1 = 0 ;
14055 int res1 = 0 ;
14056 int val2 ;
14057 int ecode2 = 0 ;
14058 PyObject * obj0 = 0 ;
14059 PyObject * obj1 = 0 ;
14060 char * kwnames[] = {
14061 (char *) "self",(char *) "radius", NULL
14062 };
14063
14064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
14065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14066 if (!SWIG_IsOK(res1)) {
14067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
14068 }
14069 arg1 = reinterpret_cast< wxImage * >(argp1);
14070 ecode2 = SWIG_AsVal_int(obj1, &val2);
14071 if (!SWIG_IsOK(ecode2)) {
14072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
14073 }
14074 arg2 = static_cast< int >(val2);
14075 {
14076 PyThreadState* __tstate = wxPyBeginAllowThreads();
14077 result = (arg1)->BlurHorizontal(arg2);
14078 wxPyEndAllowThreads(__tstate);
14079 if (PyErr_Occurred()) SWIG_fail;
14080 }
14081 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14082 return resultobj;
14083 fail:
14084 return NULL;
14085 }
14086
14087
14088 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14089 PyObject *resultobj = 0;
14090 wxImage *arg1 = (wxImage *) 0 ;
14091 int arg2 ;
14092 SwigValueWrapper<wxImage > result;
14093 void *argp1 = 0 ;
14094 int res1 = 0 ;
14095 int val2 ;
14096 int ecode2 = 0 ;
14097 PyObject * obj0 = 0 ;
14098 PyObject * obj1 = 0 ;
14099 char * kwnames[] = {
14100 (char *) "self",(char *) "radius", NULL
14101 };
14102
14103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
14104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14105 if (!SWIG_IsOK(res1)) {
14106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
14107 }
14108 arg1 = reinterpret_cast< wxImage * >(argp1);
14109 ecode2 = SWIG_AsVal_int(obj1, &val2);
14110 if (!SWIG_IsOK(ecode2)) {
14111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
14112 }
14113 arg2 = static_cast< int >(val2);
14114 {
14115 PyThreadState* __tstate = wxPyBeginAllowThreads();
14116 result = (arg1)->BlurVertical(arg2);
14117 wxPyEndAllowThreads(__tstate);
14118 if (PyErr_Occurred()) SWIG_fail;
14119 }
14120 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14121 return resultobj;
14122 fail:
14123 return NULL;
14124 }
14125
14126
14127 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14128 PyObject *resultobj = 0;
14129 wxImage *arg1 = (wxImage *) 0 ;
14130 int arg2 ;
14131 int arg3 ;
14132 SwigValueWrapper<wxImage > result;
14133 void *argp1 = 0 ;
14134 int res1 = 0 ;
14135 int val2 ;
14136 int ecode2 = 0 ;
14137 int val3 ;
14138 int ecode3 = 0 ;
14139 PyObject * obj0 = 0 ;
14140 PyObject * obj1 = 0 ;
14141 PyObject * obj2 = 0 ;
14142 char * kwnames[] = {
14143 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
14144 };
14145
14146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14148 if (!SWIG_IsOK(res1)) {
14149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
14150 }
14151 arg1 = reinterpret_cast< wxImage * >(argp1);
14152 ecode2 = SWIG_AsVal_int(obj1, &val2);
14153 if (!SWIG_IsOK(ecode2)) {
14154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
14155 }
14156 arg2 = static_cast< int >(val2);
14157 ecode3 = SWIG_AsVal_int(obj2, &val3);
14158 if (!SWIG_IsOK(ecode3)) {
14159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
14160 }
14161 arg3 = static_cast< int >(val3);
14162 {
14163 PyThreadState* __tstate = wxPyBeginAllowThreads();
14164 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
14165 wxPyEndAllowThreads(__tstate);
14166 if (PyErr_Occurred()) SWIG_fail;
14167 }
14168 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14169 return resultobj;
14170 fail:
14171 return NULL;
14172 }
14173
14174
14175 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14176 PyObject *resultobj = 0;
14177 wxImage *arg1 = (wxImage *) 0 ;
14178 int arg2 ;
14179 int arg3 ;
14180 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
14181 wxImage *result = 0 ;
14182 void *argp1 = 0 ;
14183 int res1 = 0 ;
14184 int val2 ;
14185 int ecode2 = 0 ;
14186 int val3 ;
14187 int ecode3 = 0 ;
14188 int val4 ;
14189 int ecode4 = 0 ;
14190 PyObject * obj0 = 0 ;
14191 PyObject * obj1 = 0 ;
14192 PyObject * obj2 = 0 ;
14193 PyObject * obj3 = 0 ;
14194 char * kwnames[] = {
14195 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
14196 };
14197
14198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14200 if (!SWIG_IsOK(res1)) {
14201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
14202 }
14203 arg1 = reinterpret_cast< wxImage * >(argp1);
14204 ecode2 = SWIG_AsVal_int(obj1, &val2);
14205 if (!SWIG_IsOK(ecode2)) {
14206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
14207 }
14208 arg2 = static_cast< int >(val2);
14209 ecode3 = SWIG_AsVal_int(obj2, &val3);
14210 if (!SWIG_IsOK(ecode3)) {
14211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
14212 }
14213 arg3 = static_cast< int >(val3);
14214 if (obj3) {
14215 ecode4 = SWIG_AsVal_int(obj3, &val4);
14216 if (!SWIG_IsOK(ecode4)) {
14217 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
14218 }
14219 arg4 = static_cast< int >(val4);
14220 }
14221 {
14222 PyThreadState* __tstate = wxPyBeginAllowThreads();
14223 {
14224 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
14225 result = (wxImage *) &_result_ref;
14226 }
14227 wxPyEndAllowThreads(__tstate);
14228 if (PyErr_Occurred()) SWIG_fail;
14229 }
14230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14231 return resultobj;
14232 fail:
14233 return NULL;
14234 }
14235
14236
14237 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14238 PyObject *resultobj = 0;
14239 wxImage *arg1 = (wxImage *) 0 ;
14240 wxSize *arg2 = 0 ;
14241 wxPoint *arg3 = 0 ;
14242 int arg4 = (int) -1 ;
14243 int arg5 = (int) -1 ;
14244 int arg6 = (int) -1 ;
14245 wxImage *result = 0 ;
14246 void *argp1 = 0 ;
14247 int res1 = 0 ;
14248 wxSize temp2 ;
14249 wxPoint temp3 ;
14250 int val4 ;
14251 int ecode4 = 0 ;
14252 int val5 ;
14253 int ecode5 = 0 ;
14254 int val6 ;
14255 int ecode6 = 0 ;
14256 PyObject * obj0 = 0 ;
14257 PyObject * obj1 = 0 ;
14258 PyObject * obj2 = 0 ;
14259 PyObject * obj3 = 0 ;
14260 PyObject * obj4 = 0 ;
14261 PyObject * obj5 = 0 ;
14262 char * kwnames[] = {
14263 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
14264 };
14265
14266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14268 if (!SWIG_IsOK(res1)) {
14269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
14270 }
14271 arg1 = reinterpret_cast< wxImage * >(argp1);
14272 {
14273 arg2 = &temp2;
14274 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
14275 }
14276 {
14277 arg3 = &temp3;
14278 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14279 }
14280 if (obj3) {
14281 ecode4 = SWIG_AsVal_int(obj3, &val4);
14282 if (!SWIG_IsOK(ecode4)) {
14283 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
14284 }
14285 arg4 = static_cast< int >(val4);
14286 }
14287 if (obj4) {
14288 ecode5 = SWIG_AsVal_int(obj4, &val5);
14289 if (!SWIG_IsOK(ecode5)) {
14290 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
14291 }
14292 arg5 = static_cast< int >(val5);
14293 }
14294 if (obj5) {
14295 ecode6 = SWIG_AsVal_int(obj5, &val6);
14296 if (!SWIG_IsOK(ecode6)) {
14297 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
14298 }
14299 arg6 = static_cast< int >(val6);
14300 }
14301 {
14302 PyThreadState* __tstate = wxPyBeginAllowThreads();
14303 {
14304 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
14305 result = (wxImage *) &_result_ref;
14306 }
14307 wxPyEndAllowThreads(__tstate);
14308 if (PyErr_Occurred()) SWIG_fail;
14309 }
14310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14311 return resultobj;
14312 fail:
14313 return NULL;
14314 }
14315
14316
14317 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14318 PyObject *resultobj = 0;
14319 wxImage *arg1 = (wxImage *) 0 ;
14320 int arg2 ;
14321 int arg3 ;
14322 byte arg4 ;
14323 byte arg5 ;
14324 byte arg6 ;
14325 void *argp1 = 0 ;
14326 int res1 = 0 ;
14327 int val2 ;
14328 int ecode2 = 0 ;
14329 int val3 ;
14330 int ecode3 = 0 ;
14331 unsigned char val4 ;
14332 int ecode4 = 0 ;
14333 unsigned char val5 ;
14334 int ecode5 = 0 ;
14335 unsigned char val6 ;
14336 int ecode6 = 0 ;
14337 PyObject * obj0 = 0 ;
14338 PyObject * obj1 = 0 ;
14339 PyObject * obj2 = 0 ;
14340 PyObject * obj3 = 0 ;
14341 PyObject * obj4 = 0 ;
14342 PyObject * obj5 = 0 ;
14343 char * kwnames[] = {
14344 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
14345 };
14346
14347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14349 if (!SWIG_IsOK(res1)) {
14350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
14351 }
14352 arg1 = reinterpret_cast< wxImage * >(argp1);
14353 ecode2 = SWIG_AsVal_int(obj1, &val2);
14354 if (!SWIG_IsOK(ecode2)) {
14355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
14356 }
14357 arg2 = static_cast< int >(val2);
14358 ecode3 = SWIG_AsVal_int(obj2, &val3);
14359 if (!SWIG_IsOK(ecode3)) {
14360 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
14361 }
14362 arg3 = static_cast< int >(val3);
14363 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14364 if (!SWIG_IsOK(ecode4)) {
14365 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
14366 }
14367 arg4 = static_cast< byte >(val4);
14368 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14369 if (!SWIG_IsOK(ecode5)) {
14370 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
14371 }
14372 arg5 = static_cast< byte >(val5);
14373 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
14374 if (!SWIG_IsOK(ecode6)) {
14375 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
14376 }
14377 arg6 = static_cast< byte >(val6);
14378 {
14379 PyThreadState* __tstate = wxPyBeginAllowThreads();
14380 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
14381 wxPyEndAllowThreads(__tstate);
14382 if (PyErr_Occurred()) SWIG_fail;
14383 }
14384 resultobj = SWIG_Py_Void();
14385 return resultobj;
14386 fail:
14387 return NULL;
14388 }
14389
14390
14391 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14392 PyObject *resultobj = 0;
14393 wxImage *arg1 = (wxImage *) 0 ;
14394 wxRect *arg2 = 0 ;
14395 byte arg3 ;
14396 byte arg4 ;
14397 byte arg5 ;
14398 void *argp1 = 0 ;
14399 int res1 = 0 ;
14400 wxRect temp2 ;
14401 unsigned char val3 ;
14402 int ecode3 = 0 ;
14403 unsigned char val4 ;
14404 int ecode4 = 0 ;
14405 unsigned char val5 ;
14406 int ecode5 = 0 ;
14407 PyObject * obj0 = 0 ;
14408 PyObject * obj1 = 0 ;
14409 PyObject * obj2 = 0 ;
14410 PyObject * obj3 = 0 ;
14411 PyObject * obj4 = 0 ;
14412 char * kwnames[] = {
14413 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
14414 };
14415
14416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14418 if (!SWIG_IsOK(res1)) {
14419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
14420 }
14421 arg1 = reinterpret_cast< wxImage * >(argp1);
14422 {
14423 arg2 = &temp2;
14424 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14425 }
14426 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14427 if (!SWIG_IsOK(ecode3)) {
14428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
14429 }
14430 arg3 = static_cast< byte >(val3);
14431 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14432 if (!SWIG_IsOK(ecode4)) {
14433 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
14434 }
14435 arg4 = static_cast< byte >(val4);
14436 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14437 if (!SWIG_IsOK(ecode5)) {
14438 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
14439 }
14440 arg5 = static_cast< byte >(val5);
14441 {
14442 PyThreadState* __tstate = wxPyBeginAllowThreads();
14443 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14444 wxPyEndAllowThreads(__tstate);
14445 if (PyErr_Occurred()) SWIG_fail;
14446 }
14447 resultobj = SWIG_Py_Void();
14448 return resultobj;
14449 fail:
14450 return NULL;
14451 }
14452
14453
14454 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14455 PyObject *resultobj = 0;
14456 wxImage *arg1 = (wxImage *) 0 ;
14457 int arg2 ;
14458 int arg3 ;
14459 byte result;
14460 void *argp1 = 0 ;
14461 int res1 = 0 ;
14462 int val2 ;
14463 int ecode2 = 0 ;
14464 int val3 ;
14465 int ecode3 = 0 ;
14466 PyObject * obj0 = 0 ;
14467 PyObject * obj1 = 0 ;
14468 PyObject * obj2 = 0 ;
14469 char * kwnames[] = {
14470 (char *) "self",(char *) "x",(char *) "y", NULL
14471 };
14472
14473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14475 if (!SWIG_IsOK(res1)) {
14476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14477 }
14478 arg1 = reinterpret_cast< wxImage * >(argp1);
14479 ecode2 = SWIG_AsVal_int(obj1, &val2);
14480 if (!SWIG_IsOK(ecode2)) {
14481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14482 }
14483 arg2 = static_cast< int >(val2);
14484 ecode3 = SWIG_AsVal_int(obj2, &val3);
14485 if (!SWIG_IsOK(ecode3)) {
14486 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14487 }
14488 arg3 = static_cast< int >(val3);
14489 {
14490 PyThreadState* __tstate = wxPyBeginAllowThreads();
14491 result = (byte)(arg1)->GetRed(arg2,arg3);
14492 wxPyEndAllowThreads(__tstate);
14493 if (PyErr_Occurred()) SWIG_fail;
14494 }
14495 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14496 return resultobj;
14497 fail:
14498 return NULL;
14499 }
14500
14501
14502 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14503 PyObject *resultobj = 0;
14504 wxImage *arg1 = (wxImage *) 0 ;
14505 int arg2 ;
14506 int arg3 ;
14507 byte result;
14508 void *argp1 = 0 ;
14509 int res1 = 0 ;
14510 int val2 ;
14511 int ecode2 = 0 ;
14512 int val3 ;
14513 int ecode3 = 0 ;
14514 PyObject * obj0 = 0 ;
14515 PyObject * obj1 = 0 ;
14516 PyObject * obj2 = 0 ;
14517 char * kwnames[] = {
14518 (char *) "self",(char *) "x",(char *) "y", NULL
14519 };
14520
14521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14523 if (!SWIG_IsOK(res1)) {
14524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14525 }
14526 arg1 = reinterpret_cast< wxImage * >(argp1);
14527 ecode2 = SWIG_AsVal_int(obj1, &val2);
14528 if (!SWIG_IsOK(ecode2)) {
14529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14530 }
14531 arg2 = static_cast< int >(val2);
14532 ecode3 = SWIG_AsVal_int(obj2, &val3);
14533 if (!SWIG_IsOK(ecode3)) {
14534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14535 }
14536 arg3 = static_cast< int >(val3);
14537 {
14538 PyThreadState* __tstate = wxPyBeginAllowThreads();
14539 result = (byte)(arg1)->GetGreen(arg2,arg3);
14540 wxPyEndAllowThreads(__tstate);
14541 if (PyErr_Occurred()) SWIG_fail;
14542 }
14543 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14544 return resultobj;
14545 fail:
14546 return NULL;
14547 }
14548
14549
14550 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14551 PyObject *resultobj = 0;
14552 wxImage *arg1 = (wxImage *) 0 ;
14553 int arg2 ;
14554 int arg3 ;
14555 byte result;
14556 void *argp1 = 0 ;
14557 int res1 = 0 ;
14558 int val2 ;
14559 int ecode2 = 0 ;
14560 int val3 ;
14561 int ecode3 = 0 ;
14562 PyObject * obj0 = 0 ;
14563 PyObject * obj1 = 0 ;
14564 PyObject * obj2 = 0 ;
14565 char * kwnames[] = {
14566 (char *) "self",(char *) "x",(char *) "y", NULL
14567 };
14568
14569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14571 if (!SWIG_IsOK(res1)) {
14572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14573 }
14574 arg1 = reinterpret_cast< wxImage * >(argp1);
14575 ecode2 = SWIG_AsVal_int(obj1, &val2);
14576 if (!SWIG_IsOK(ecode2)) {
14577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14578 }
14579 arg2 = static_cast< int >(val2);
14580 ecode3 = SWIG_AsVal_int(obj2, &val3);
14581 if (!SWIG_IsOK(ecode3)) {
14582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14583 }
14584 arg3 = static_cast< int >(val3);
14585 {
14586 PyThreadState* __tstate = wxPyBeginAllowThreads();
14587 result = (byte)(arg1)->GetBlue(arg2,arg3);
14588 wxPyEndAllowThreads(__tstate);
14589 if (PyErr_Occurred()) SWIG_fail;
14590 }
14591 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14592 return resultobj;
14593 fail:
14594 return NULL;
14595 }
14596
14597
14598 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14599 PyObject *resultobj = 0;
14600 wxImage *arg1 = (wxImage *) 0 ;
14601 int arg2 ;
14602 int arg3 ;
14603 byte arg4 ;
14604 void *argp1 = 0 ;
14605 int res1 = 0 ;
14606 int val2 ;
14607 int ecode2 = 0 ;
14608 int val3 ;
14609 int ecode3 = 0 ;
14610 unsigned char val4 ;
14611 int ecode4 = 0 ;
14612 PyObject * obj0 = 0 ;
14613 PyObject * obj1 = 0 ;
14614 PyObject * obj2 = 0 ;
14615 PyObject * obj3 = 0 ;
14616 char * kwnames[] = {
14617 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14618 };
14619
14620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14622 if (!SWIG_IsOK(res1)) {
14623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14624 }
14625 arg1 = reinterpret_cast< wxImage * >(argp1);
14626 ecode2 = SWIG_AsVal_int(obj1, &val2);
14627 if (!SWIG_IsOK(ecode2)) {
14628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14629 }
14630 arg2 = static_cast< int >(val2);
14631 ecode3 = SWIG_AsVal_int(obj2, &val3);
14632 if (!SWIG_IsOK(ecode3)) {
14633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14634 }
14635 arg3 = static_cast< int >(val3);
14636 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14637 if (!SWIG_IsOK(ecode4)) {
14638 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14639 }
14640 arg4 = static_cast< byte >(val4);
14641 {
14642 PyThreadState* __tstate = wxPyBeginAllowThreads();
14643 (arg1)->SetAlpha(arg2,arg3,arg4);
14644 wxPyEndAllowThreads(__tstate);
14645 if (PyErr_Occurred()) SWIG_fail;
14646 }
14647 resultobj = SWIG_Py_Void();
14648 return resultobj;
14649 fail:
14650 return NULL;
14651 }
14652
14653
14654 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14655 PyObject *resultobj = 0;
14656 wxImage *arg1 = (wxImage *) 0 ;
14657 int arg2 ;
14658 int arg3 ;
14659 byte result;
14660 void *argp1 = 0 ;
14661 int res1 = 0 ;
14662 int val2 ;
14663 int ecode2 = 0 ;
14664 int val3 ;
14665 int ecode3 = 0 ;
14666 PyObject * obj0 = 0 ;
14667 PyObject * obj1 = 0 ;
14668 PyObject * obj2 = 0 ;
14669 char * kwnames[] = {
14670 (char *) "self",(char *) "x",(char *) "y", NULL
14671 };
14672
14673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14675 if (!SWIG_IsOK(res1)) {
14676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14677 }
14678 arg1 = reinterpret_cast< wxImage * >(argp1);
14679 ecode2 = SWIG_AsVal_int(obj1, &val2);
14680 if (!SWIG_IsOK(ecode2)) {
14681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14682 }
14683 arg2 = static_cast< int >(val2);
14684 ecode3 = SWIG_AsVal_int(obj2, &val3);
14685 if (!SWIG_IsOK(ecode3)) {
14686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14687 }
14688 arg3 = static_cast< int >(val3);
14689 {
14690 PyThreadState* __tstate = wxPyBeginAllowThreads();
14691 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14692 wxPyEndAllowThreads(__tstate);
14693 if (PyErr_Occurred()) SWIG_fail;
14694 }
14695 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14696 return resultobj;
14697 fail:
14698 return NULL;
14699 }
14700
14701
14702 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14703 PyObject *resultobj = 0;
14704 wxImage *arg1 = (wxImage *) 0 ;
14705 bool result;
14706 void *argp1 = 0 ;
14707 int res1 = 0 ;
14708 PyObject *swig_obj[1] ;
14709
14710 if (!args) SWIG_fail;
14711 swig_obj[0] = args;
14712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14713 if (!SWIG_IsOK(res1)) {
14714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14715 }
14716 arg1 = reinterpret_cast< wxImage * >(argp1);
14717 {
14718 PyThreadState* __tstate = wxPyBeginAllowThreads();
14719 result = (bool)(arg1)->HasAlpha();
14720 wxPyEndAllowThreads(__tstate);
14721 if (PyErr_Occurred()) SWIG_fail;
14722 }
14723 {
14724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14725 }
14726 return resultobj;
14727 fail:
14728 return NULL;
14729 }
14730
14731
14732 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14733 PyObject *resultobj = 0;
14734 wxImage *arg1 = (wxImage *) 0 ;
14735 void *argp1 = 0 ;
14736 int res1 = 0 ;
14737 PyObject *swig_obj[1] ;
14738
14739 if (!args) SWIG_fail;
14740 swig_obj[0] = args;
14741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14742 if (!SWIG_IsOK(res1)) {
14743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14744 }
14745 arg1 = reinterpret_cast< wxImage * >(argp1);
14746 {
14747 PyThreadState* __tstate = wxPyBeginAllowThreads();
14748 (arg1)->InitAlpha();
14749 wxPyEndAllowThreads(__tstate);
14750 if (PyErr_Occurred()) SWIG_fail;
14751 }
14752 resultobj = SWIG_Py_Void();
14753 return resultobj;
14754 fail:
14755 return NULL;
14756 }
14757
14758
14759 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14760 PyObject *resultobj = 0;
14761 wxImage *arg1 = (wxImage *) 0 ;
14762 int arg2 ;
14763 int arg3 ;
14764 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14765 bool result;
14766 void *argp1 = 0 ;
14767 int res1 = 0 ;
14768 int val2 ;
14769 int ecode2 = 0 ;
14770 int val3 ;
14771 int ecode3 = 0 ;
14772 unsigned char val4 ;
14773 int ecode4 = 0 ;
14774 PyObject * obj0 = 0 ;
14775 PyObject * obj1 = 0 ;
14776 PyObject * obj2 = 0 ;
14777 PyObject * obj3 = 0 ;
14778 char * kwnames[] = {
14779 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14780 };
14781
14782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14784 if (!SWIG_IsOK(res1)) {
14785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14786 }
14787 arg1 = reinterpret_cast< wxImage * >(argp1);
14788 ecode2 = SWIG_AsVal_int(obj1, &val2);
14789 if (!SWIG_IsOK(ecode2)) {
14790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14791 }
14792 arg2 = static_cast< int >(val2);
14793 ecode3 = SWIG_AsVal_int(obj2, &val3);
14794 if (!SWIG_IsOK(ecode3)) {
14795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14796 }
14797 arg3 = static_cast< int >(val3);
14798 if (obj3) {
14799 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14800 if (!SWIG_IsOK(ecode4)) {
14801 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14802 }
14803 arg4 = static_cast< byte >(val4);
14804 }
14805 {
14806 PyThreadState* __tstate = wxPyBeginAllowThreads();
14807 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14808 wxPyEndAllowThreads(__tstate);
14809 if (PyErr_Occurred()) SWIG_fail;
14810 }
14811 {
14812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14813 }
14814 return resultobj;
14815 fail:
14816 return NULL;
14817 }
14818
14819
14820 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14821 PyObject *resultobj = 0;
14822 wxImage *arg1 = (wxImage *) 0 ;
14823 byte *arg2 = (byte *) 0 ;
14824 byte *arg3 = (byte *) 0 ;
14825 byte *arg4 = (byte *) 0 ;
14826 byte arg5 = (byte) 0 ;
14827 byte arg6 = (byte) 0 ;
14828 byte arg7 = (byte) 0 ;
14829 bool result;
14830 void *argp1 = 0 ;
14831 int res1 = 0 ;
14832 byte temp2 ;
14833 int res2 = SWIG_TMPOBJ ;
14834 byte temp3 ;
14835 int res3 = SWIG_TMPOBJ ;
14836 byte temp4 ;
14837 int res4 = SWIG_TMPOBJ ;
14838 unsigned char val5 ;
14839 int ecode5 = 0 ;
14840 unsigned char val6 ;
14841 int ecode6 = 0 ;
14842 unsigned char val7 ;
14843 int ecode7 = 0 ;
14844 PyObject * obj0 = 0 ;
14845 PyObject * obj1 = 0 ;
14846 PyObject * obj2 = 0 ;
14847 PyObject * obj3 = 0 ;
14848 char * kwnames[] = {
14849 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14850 };
14851
14852 arg2 = &temp2;
14853 arg3 = &temp3;
14854 arg4 = &temp4;
14855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14857 if (!SWIG_IsOK(res1)) {
14858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14859 }
14860 arg1 = reinterpret_cast< wxImage * >(argp1);
14861 if (obj1) {
14862 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14863 if (!SWIG_IsOK(ecode5)) {
14864 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14865 }
14866 arg5 = static_cast< byte >(val5);
14867 }
14868 if (obj2) {
14869 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14870 if (!SWIG_IsOK(ecode6)) {
14871 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14872 }
14873 arg6 = static_cast< byte >(val6);
14874 }
14875 if (obj3) {
14876 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14877 if (!SWIG_IsOK(ecode7)) {
14878 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14879 }
14880 arg7 = static_cast< byte >(val7);
14881 }
14882 {
14883 PyThreadState* __tstate = wxPyBeginAllowThreads();
14884 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14885 wxPyEndAllowThreads(__tstate);
14886 if (PyErr_Occurred()) SWIG_fail;
14887 }
14888 {
14889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14890 }
14891 if (SWIG_IsTmpObj(res2)) {
14892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14893 } else {
14894 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14896 }
14897 if (SWIG_IsTmpObj(res3)) {
14898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14899 } else {
14900 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14902 }
14903 if (SWIG_IsTmpObj(res4)) {
14904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14905 } else {
14906 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14908 }
14909 return resultobj;
14910 fail:
14911 return NULL;
14912 }
14913
14914
14915 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14916 PyObject *resultobj = 0;
14917 wxImage *arg1 = (wxImage *) 0 ;
14918 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14919 bool result;
14920 void *argp1 = 0 ;
14921 int res1 = 0 ;
14922 unsigned char val2 ;
14923 int ecode2 = 0 ;
14924 PyObject * obj0 = 0 ;
14925 PyObject * obj1 = 0 ;
14926 char * kwnames[] = {
14927 (char *) "self",(char *) "threshold", NULL
14928 };
14929
14930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14932 if (!SWIG_IsOK(res1)) {
14933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14934 }
14935 arg1 = reinterpret_cast< wxImage * >(argp1);
14936 if (obj1) {
14937 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14938 if (!SWIG_IsOK(ecode2)) {
14939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14940 }
14941 arg2 = static_cast< byte >(val2);
14942 }
14943 {
14944 PyThreadState* __tstate = wxPyBeginAllowThreads();
14945 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14946 wxPyEndAllowThreads(__tstate);
14947 if (PyErr_Occurred()) SWIG_fail;
14948 }
14949 {
14950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14951 }
14952 return resultobj;
14953 fail:
14954 return NULL;
14955 }
14956
14957
14958 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14959 PyObject *resultobj = 0;
14960 wxImage *arg1 = (wxImage *) 0 ;
14961 byte arg2 ;
14962 byte arg3 ;
14963 byte arg4 ;
14964 bool result;
14965 void *argp1 = 0 ;
14966 int res1 = 0 ;
14967 unsigned char val2 ;
14968 int ecode2 = 0 ;
14969 unsigned char val3 ;
14970 int ecode3 = 0 ;
14971 unsigned char val4 ;
14972 int ecode4 = 0 ;
14973 PyObject * obj0 = 0 ;
14974 PyObject * obj1 = 0 ;
14975 PyObject * obj2 = 0 ;
14976 PyObject * obj3 = 0 ;
14977 char * kwnames[] = {
14978 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14979 };
14980
14981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14983 if (!SWIG_IsOK(res1)) {
14984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14985 }
14986 arg1 = reinterpret_cast< wxImage * >(argp1);
14987 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14988 if (!SWIG_IsOK(ecode2)) {
14989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14990 }
14991 arg2 = static_cast< byte >(val2);
14992 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14993 if (!SWIG_IsOK(ecode3)) {
14994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14995 }
14996 arg3 = static_cast< byte >(val3);
14997 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14998 if (!SWIG_IsOK(ecode4)) {
14999 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
15000 }
15001 arg4 = static_cast< byte >(val4);
15002 {
15003 PyThreadState* __tstate = wxPyBeginAllowThreads();
15004 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
15005 wxPyEndAllowThreads(__tstate);
15006 if (PyErr_Occurred()) SWIG_fail;
15007 }
15008 {
15009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15010 }
15011 return resultobj;
15012 fail:
15013 return NULL;
15014 }
15015
15016
15017 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15018 PyObject *resultobj = 0;
15019 wxImage *arg1 = (wxImage *) 0 ;
15020 wxImage *arg2 = 0 ;
15021 byte arg3 ;
15022 byte arg4 ;
15023 byte arg5 ;
15024 bool result;
15025 void *argp1 = 0 ;
15026 int res1 = 0 ;
15027 void *argp2 = 0 ;
15028 int res2 = 0 ;
15029 unsigned char val3 ;
15030 int ecode3 = 0 ;
15031 unsigned char val4 ;
15032 int ecode4 = 0 ;
15033 unsigned char val5 ;
15034 int ecode5 = 0 ;
15035 PyObject * obj0 = 0 ;
15036 PyObject * obj1 = 0 ;
15037 PyObject * obj2 = 0 ;
15038 PyObject * obj3 = 0 ;
15039 PyObject * obj4 = 0 ;
15040 char * kwnames[] = {
15041 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
15042 };
15043
15044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15046 if (!SWIG_IsOK(res1)) {
15047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
15048 }
15049 arg1 = reinterpret_cast< wxImage * >(argp1);
15050 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15051 if (!SWIG_IsOK(res2)) {
15052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15053 }
15054 if (!argp2) {
15055 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15056 }
15057 arg2 = reinterpret_cast< wxImage * >(argp2);
15058 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15059 if (!SWIG_IsOK(ecode3)) {
15060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
15061 }
15062 arg3 = static_cast< byte >(val3);
15063 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15064 if (!SWIG_IsOK(ecode4)) {
15065 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
15066 }
15067 arg4 = static_cast< byte >(val4);
15068 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15069 if (!SWIG_IsOK(ecode5)) {
15070 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
15071 }
15072 arg5 = static_cast< byte >(val5);
15073 {
15074 PyThreadState* __tstate = wxPyBeginAllowThreads();
15075 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
15076 wxPyEndAllowThreads(__tstate);
15077 if (PyErr_Occurred()) SWIG_fail;
15078 }
15079 {
15080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15081 }
15082 return resultobj;
15083 fail:
15084 return NULL;
15085 }
15086
15087
15088 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15089 PyObject *resultobj = 0;
15090 wxString *arg1 = 0 ;
15091 bool result;
15092 bool temp1 = false ;
15093 PyObject * obj0 = 0 ;
15094 char * kwnames[] = {
15095 (char *) "filename", NULL
15096 };
15097
15098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
15099 {
15100 arg1 = wxString_in_helper(obj0);
15101 if (arg1 == NULL) SWIG_fail;
15102 temp1 = true;
15103 }
15104 {
15105 PyThreadState* __tstate = wxPyBeginAllowThreads();
15106 result = (bool)wxImage::CanRead((wxString const &)*arg1);
15107 wxPyEndAllowThreads(__tstate);
15108 if (PyErr_Occurred()) SWIG_fail;
15109 }
15110 {
15111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15112 }
15113 {
15114 if (temp1)
15115 delete arg1;
15116 }
15117 return resultobj;
15118 fail:
15119 {
15120 if (temp1)
15121 delete arg1;
15122 }
15123 return NULL;
15124 }
15125
15126
15127 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15128 PyObject *resultobj = 0;
15129 wxString *arg1 = 0 ;
15130 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15131 int result;
15132 bool temp1 = false ;
15133 long val2 ;
15134 int ecode2 = 0 ;
15135 PyObject * obj0 = 0 ;
15136 PyObject * obj1 = 0 ;
15137 char * kwnames[] = {
15138 (char *) "filename",(char *) "type", NULL
15139 };
15140
15141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
15142 {
15143 arg1 = wxString_in_helper(obj0);
15144 if (arg1 == NULL) SWIG_fail;
15145 temp1 = true;
15146 }
15147 if (obj1) {
15148 ecode2 = SWIG_AsVal_long(obj1, &val2);
15149 if (!SWIG_IsOK(ecode2)) {
15150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
15151 }
15152 arg2 = static_cast< long >(val2);
15153 }
15154 {
15155 PyThreadState* __tstate = wxPyBeginAllowThreads();
15156 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
15157 wxPyEndAllowThreads(__tstate);
15158 if (PyErr_Occurred()) SWIG_fail;
15159 }
15160 resultobj = SWIG_From_int(static_cast< int >(result));
15161 {
15162 if (temp1)
15163 delete arg1;
15164 }
15165 return resultobj;
15166 fail:
15167 {
15168 if (temp1)
15169 delete arg1;
15170 }
15171 return NULL;
15172 }
15173
15174
15175 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15176 PyObject *resultobj = 0;
15177 wxImage *arg1 = (wxImage *) 0 ;
15178 wxString *arg2 = 0 ;
15179 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15180 int arg4 = (int) -1 ;
15181 bool result;
15182 void *argp1 = 0 ;
15183 int res1 = 0 ;
15184 bool temp2 = false ;
15185 long val3 ;
15186 int ecode3 = 0 ;
15187 int val4 ;
15188 int ecode4 = 0 ;
15189 PyObject * obj0 = 0 ;
15190 PyObject * obj1 = 0 ;
15191 PyObject * obj2 = 0 ;
15192 PyObject * obj3 = 0 ;
15193 char * kwnames[] = {
15194 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
15195 };
15196
15197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15199 if (!SWIG_IsOK(res1)) {
15200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
15201 }
15202 arg1 = reinterpret_cast< wxImage * >(argp1);
15203 {
15204 arg2 = wxString_in_helper(obj1);
15205 if (arg2 == NULL) SWIG_fail;
15206 temp2 = true;
15207 }
15208 if (obj2) {
15209 ecode3 = SWIG_AsVal_long(obj2, &val3);
15210 if (!SWIG_IsOK(ecode3)) {
15211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
15212 }
15213 arg3 = static_cast< long >(val3);
15214 }
15215 if (obj3) {
15216 ecode4 = SWIG_AsVal_int(obj3, &val4);
15217 if (!SWIG_IsOK(ecode4)) {
15218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
15219 }
15220 arg4 = static_cast< int >(val4);
15221 }
15222 {
15223 PyThreadState* __tstate = wxPyBeginAllowThreads();
15224 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
15225 wxPyEndAllowThreads(__tstate);
15226 if (PyErr_Occurred()) SWIG_fail;
15227 }
15228 {
15229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15230 }
15231 {
15232 if (temp2)
15233 delete arg2;
15234 }
15235 return resultobj;
15236 fail:
15237 {
15238 if (temp2)
15239 delete arg2;
15240 }
15241 return NULL;
15242 }
15243
15244
15245 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15246 PyObject *resultobj = 0;
15247 wxImage *arg1 = (wxImage *) 0 ;
15248 wxString *arg2 = 0 ;
15249 wxString *arg3 = 0 ;
15250 int arg4 = (int) -1 ;
15251 bool result;
15252 void *argp1 = 0 ;
15253 int res1 = 0 ;
15254 bool temp2 = false ;
15255 bool temp3 = false ;
15256 int val4 ;
15257 int ecode4 = 0 ;
15258 PyObject * obj0 = 0 ;
15259 PyObject * obj1 = 0 ;
15260 PyObject * obj2 = 0 ;
15261 PyObject * obj3 = 0 ;
15262 char * kwnames[] = {
15263 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
15264 };
15265
15266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15268 if (!SWIG_IsOK(res1)) {
15269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15270 }
15271 arg1 = reinterpret_cast< wxImage * >(argp1);
15272 {
15273 arg2 = wxString_in_helper(obj1);
15274 if (arg2 == NULL) SWIG_fail;
15275 temp2 = true;
15276 }
15277 {
15278 arg3 = wxString_in_helper(obj2);
15279 if (arg3 == NULL) SWIG_fail;
15280 temp3 = true;
15281 }
15282 if (obj3) {
15283 ecode4 = SWIG_AsVal_int(obj3, &val4);
15284 if (!SWIG_IsOK(ecode4)) {
15285 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
15286 }
15287 arg4 = static_cast< int >(val4);
15288 }
15289 {
15290 PyThreadState* __tstate = wxPyBeginAllowThreads();
15291 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
15292 wxPyEndAllowThreads(__tstate);
15293 if (PyErr_Occurred()) SWIG_fail;
15294 }
15295 {
15296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15297 }
15298 {
15299 if (temp2)
15300 delete arg2;
15301 }
15302 {
15303 if (temp3)
15304 delete arg3;
15305 }
15306 return resultobj;
15307 fail:
15308 {
15309 if (temp2)
15310 delete arg2;
15311 }
15312 {
15313 if (temp3)
15314 delete arg3;
15315 }
15316 return NULL;
15317 }
15318
15319
15320 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15321 PyObject *resultobj = 0;
15322 wxImage *arg1 = (wxImage *) 0 ;
15323 wxString *arg2 = 0 ;
15324 int arg3 ;
15325 bool result;
15326 void *argp1 = 0 ;
15327 int res1 = 0 ;
15328 bool temp2 = false ;
15329 int val3 ;
15330 int ecode3 = 0 ;
15331 PyObject * obj0 = 0 ;
15332 PyObject * obj1 = 0 ;
15333 PyObject * obj2 = 0 ;
15334 char * kwnames[] = {
15335 (char *) "self",(char *) "name",(char *) "type", NULL
15336 };
15337
15338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15340 if (!SWIG_IsOK(res1)) {
15341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
15342 }
15343 arg1 = reinterpret_cast< wxImage * >(argp1);
15344 {
15345 arg2 = wxString_in_helper(obj1);
15346 if (arg2 == NULL) SWIG_fail;
15347 temp2 = true;
15348 }
15349 ecode3 = SWIG_AsVal_int(obj2, &val3);
15350 if (!SWIG_IsOK(ecode3)) {
15351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
15352 }
15353 arg3 = static_cast< int >(val3);
15354 {
15355 PyThreadState* __tstate = wxPyBeginAllowThreads();
15356 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
15357 wxPyEndAllowThreads(__tstate);
15358 if (PyErr_Occurred()) SWIG_fail;
15359 }
15360 {
15361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15362 }
15363 {
15364 if (temp2)
15365 delete arg2;
15366 }
15367 return resultobj;
15368 fail:
15369 {
15370 if (temp2)
15371 delete arg2;
15372 }
15373 return NULL;
15374 }
15375
15376
15377 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15378 PyObject *resultobj = 0;
15379 wxImage *arg1 = (wxImage *) 0 ;
15380 wxString *arg2 = 0 ;
15381 wxString *arg3 = 0 ;
15382 bool result;
15383 void *argp1 = 0 ;
15384 int res1 = 0 ;
15385 bool temp2 = false ;
15386 bool temp3 = false ;
15387 PyObject * obj0 = 0 ;
15388 PyObject * obj1 = 0 ;
15389 PyObject * obj2 = 0 ;
15390 char * kwnames[] = {
15391 (char *) "self",(char *) "name",(char *) "mimetype", NULL
15392 };
15393
15394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15396 if (!SWIG_IsOK(res1)) {
15397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15398 }
15399 arg1 = reinterpret_cast< wxImage * >(argp1);
15400 {
15401 arg2 = wxString_in_helper(obj1);
15402 if (arg2 == NULL) SWIG_fail;
15403 temp2 = true;
15404 }
15405 {
15406 arg3 = wxString_in_helper(obj2);
15407 if (arg3 == NULL) SWIG_fail;
15408 temp3 = true;
15409 }
15410 {
15411 PyThreadState* __tstate = wxPyBeginAllowThreads();
15412 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
15413 wxPyEndAllowThreads(__tstate);
15414 if (PyErr_Occurred()) SWIG_fail;
15415 }
15416 {
15417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15418 }
15419 {
15420 if (temp2)
15421 delete arg2;
15422 }
15423 {
15424 if (temp3)
15425 delete arg3;
15426 }
15427 return resultobj;
15428 fail:
15429 {
15430 if (temp2)
15431 delete arg2;
15432 }
15433 {
15434 if (temp3)
15435 delete arg3;
15436 }
15437 return NULL;
15438 }
15439
15440
15441 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15442 PyObject *resultobj = 0;
15443 wxInputStream *arg1 = 0 ;
15444 bool result;
15445 wxPyInputStream *temp1 ;
15446 bool created1 ;
15447 PyObject * obj0 = 0 ;
15448 char * kwnames[] = {
15449 (char *) "stream", NULL
15450 };
15451
15452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15453 {
15454 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15455 arg1 = temp1->m_wxis;
15456 created1 = false;
15457 } else {
15458 PyErr_Clear(); // clear the failure of the wxPyConvert above
15459 arg1 = wxPyCBInputStream_create(obj0, false);
15460 if (arg1 == NULL) {
15461 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15462 SWIG_fail;
15463 }
15464 created1 = true;
15465 }
15466 }
15467 {
15468 PyThreadState* __tstate = wxPyBeginAllowThreads();
15469 result = (bool)wxImage::CanRead(*arg1);
15470 wxPyEndAllowThreads(__tstate);
15471 if (PyErr_Occurred()) SWIG_fail;
15472 }
15473 {
15474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15475 }
15476 {
15477 if (created1) delete arg1;
15478 }
15479 return resultobj;
15480 fail:
15481 {
15482 if (created1) delete arg1;
15483 }
15484 return NULL;
15485 }
15486
15487
15488 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15489 PyObject *resultobj = 0;
15490 wxImage *arg1 = (wxImage *) 0 ;
15491 wxInputStream *arg2 = 0 ;
15492 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15493 int arg4 = (int) -1 ;
15494 bool result;
15495 void *argp1 = 0 ;
15496 int res1 = 0 ;
15497 wxPyInputStream *temp2 ;
15498 bool created2 ;
15499 long val3 ;
15500 int ecode3 = 0 ;
15501 int val4 ;
15502 int ecode4 = 0 ;
15503 PyObject * obj0 = 0 ;
15504 PyObject * obj1 = 0 ;
15505 PyObject * obj2 = 0 ;
15506 PyObject * obj3 = 0 ;
15507 char * kwnames[] = {
15508 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15509 };
15510
15511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15513 if (!SWIG_IsOK(res1)) {
15514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15515 }
15516 arg1 = reinterpret_cast< wxImage * >(argp1);
15517 {
15518 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15519 arg2 = temp2->m_wxis;
15520 created2 = false;
15521 } else {
15522 PyErr_Clear(); // clear the failure of the wxPyConvert above
15523 arg2 = wxPyCBInputStream_create(obj1, false);
15524 if (arg2 == NULL) {
15525 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15526 SWIG_fail;
15527 }
15528 created2 = true;
15529 }
15530 }
15531 if (obj2) {
15532 ecode3 = SWIG_AsVal_long(obj2, &val3);
15533 if (!SWIG_IsOK(ecode3)) {
15534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15535 }
15536 arg3 = static_cast< long >(val3);
15537 }
15538 if (obj3) {
15539 ecode4 = SWIG_AsVal_int(obj3, &val4);
15540 if (!SWIG_IsOK(ecode4)) {
15541 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15542 }
15543 arg4 = static_cast< int >(val4);
15544 }
15545 {
15546 PyThreadState* __tstate = wxPyBeginAllowThreads();
15547 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15548 wxPyEndAllowThreads(__tstate);
15549 if (PyErr_Occurred()) SWIG_fail;
15550 }
15551 {
15552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15553 }
15554 {
15555 if (created2) delete arg2;
15556 }
15557 return resultobj;
15558 fail:
15559 {
15560 if (created2) delete arg2;
15561 }
15562 return NULL;
15563 }
15564
15565
15566 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15567 PyObject *resultobj = 0;
15568 wxImage *arg1 = (wxImage *) 0 ;
15569 wxInputStream *arg2 = 0 ;
15570 wxString *arg3 = 0 ;
15571 int arg4 = (int) -1 ;
15572 bool result;
15573 void *argp1 = 0 ;
15574 int res1 = 0 ;
15575 wxPyInputStream *temp2 ;
15576 bool created2 ;
15577 bool temp3 = false ;
15578 int val4 ;
15579 int ecode4 = 0 ;
15580 PyObject * obj0 = 0 ;
15581 PyObject * obj1 = 0 ;
15582 PyObject * obj2 = 0 ;
15583 PyObject * obj3 = 0 ;
15584 char * kwnames[] = {
15585 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15586 };
15587
15588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15590 if (!SWIG_IsOK(res1)) {
15591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15592 }
15593 arg1 = reinterpret_cast< wxImage * >(argp1);
15594 {
15595 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15596 arg2 = temp2->m_wxis;
15597 created2 = false;
15598 } else {
15599 PyErr_Clear(); // clear the failure of the wxPyConvert above
15600 arg2 = wxPyCBInputStream_create(obj1, false);
15601 if (arg2 == NULL) {
15602 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15603 SWIG_fail;
15604 }
15605 created2 = true;
15606 }
15607 }
15608 {
15609 arg3 = wxString_in_helper(obj2);
15610 if (arg3 == NULL) SWIG_fail;
15611 temp3 = true;
15612 }
15613 if (obj3) {
15614 ecode4 = SWIG_AsVal_int(obj3, &val4);
15615 if (!SWIG_IsOK(ecode4)) {
15616 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15617 }
15618 arg4 = static_cast< int >(val4);
15619 }
15620 {
15621 PyThreadState* __tstate = wxPyBeginAllowThreads();
15622 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15623 wxPyEndAllowThreads(__tstate);
15624 if (PyErr_Occurred()) SWIG_fail;
15625 }
15626 {
15627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15628 }
15629 {
15630 if (created2) delete arg2;
15631 }
15632 {
15633 if (temp3)
15634 delete arg3;
15635 }
15636 return resultobj;
15637 fail:
15638 {
15639 if (created2) delete arg2;
15640 }
15641 {
15642 if (temp3)
15643 delete arg3;
15644 }
15645 return NULL;
15646 }
15647
15648
15649 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15650 PyObject *resultobj = 0;
15651 wxImage *arg1 = (wxImage *) 0 ;
15652 bool result;
15653 void *argp1 = 0 ;
15654 int res1 = 0 ;
15655 PyObject *swig_obj[1] ;
15656
15657 if (!args) SWIG_fail;
15658 swig_obj[0] = args;
15659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15660 if (!SWIG_IsOK(res1)) {
15661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15662 }
15663 arg1 = reinterpret_cast< wxImage * >(argp1);
15664 {
15665 PyThreadState* __tstate = wxPyBeginAllowThreads();
15666 result = (bool)(arg1)->Ok();
15667 wxPyEndAllowThreads(__tstate);
15668 if (PyErr_Occurred()) SWIG_fail;
15669 }
15670 {
15671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15672 }
15673 return resultobj;
15674 fail:
15675 return NULL;
15676 }
15677
15678
15679 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15680 PyObject *resultobj = 0;
15681 wxImage *arg1 = (wxImage *) 0 ;
15682 int result;
15683 void *argp1 = 0 ;
15684 int res1 = 0 ;
15685 PyObject *swig_obj[1] ;
15686
15687 if (!args) SWIG_fail;
15688 swig_obj[0] = args;
15689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15690 if (!SWIG_IsOK(res1)) {
15691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15692 }
15693 arg1 = reinterpret_cast< wxImage * >(argp1);
15694 {
15695 PyThreadState* __tstate = wxPyBeginAllowThreads();
15696 result = (int)(arg1)->GetWidth();
15697 wxPyEndAllowThreads(__tstate);
15698 if (PyErr_Occurred()) SWIG_fail;
15699 }
15700 resultobj = SWIG_From_int(static_cast< int >(result));
15701 return resultobj;
15702 fail:
15703 return NULL;
15704 }
15705
15706
15707 SWIGINTERN PyObject *_wrap_Image_GetHeight(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_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15720 }
15721 arg1 = reinterpret_cast< wxImage * >(argp1);
15722 {
15723 PyThreadState* __tstate = wxPyBeginAllowThreads();
15724 result = (int)(arg1)->GetHeight();
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_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15736 PyObject *resultobj = 0;
15737 wxImage *arg1 = (wxImage *) 0 ;
15738 wxSize 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_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15748 }
15749 arg1 = reinterpret_cast< wxImage * >(argp1);
15750 {
15751 PyThreadState* __tstate = wxPyBeginAllowThreads();
15752 result = wxImage_GetSize(arg1);
15753 wxPyEndAllowThreads(__tstate);
15754 if (PyErr_Occurred()) SWIG_fail;
15755 }
15756 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15757 return resultobj;
15758 fail:
15759 return NULL;
15760 }
15761
15762
15763 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15764 PyObject *resultobj = 0;
15765 wxImage *arg1 = (wxImage *) 0 ;
15766 wxRect *arg2 = 0 ;
15767 SwigValueWrapper<wxImage > result;
15768 void *argp1 = 0 ;
15769 int res1 = 0 ;
15770 wxRect temp2 ;
15771 PyObject * obj0 = 0 ;
15772 PyObject * obj1 = 0 ;
15773 char * kwnames[] = {
15774 (char *) "self",(char *) "rect", NULL
15775 };
15776
15777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15779 if (!SWIG_IsOK(res1)) {
15780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15781 }
15782 arg1 = reinterpret_cast< wxImage * >(argp1);
15783 {
15784 arg2 = &temp2;
15785 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15786 }
15787 {
15788 PyThreadState* __tstate = wxPyBeginAllowThreads();
15789 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15790 wxPyEndAllowThreads(__tstate);
15791 if (PyErr_Occurred()) SWIG_fail;
15792 }
15793 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15794 return resultobj;
15795 fail:
15796 return NULL;
15797 }
15798
15799
15800 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15801 PyObject *resultobj = 0;
15802 wxImage *arg1 = (wxImage *) 0 ;
15803 wxSize *arg2 = 0 ;
15804 wxPoint *arg3 = 0 ;
15805 int arg4 = (int) -1 ;
15806 int arg5 = (int) -1 ;
15807 int arg6 = (int) -1 ;
15808 SwigValueWrapper<wxImage > result;
15809 void *argp1 = 0 ;
15810 int res1 = 0 ;
15811 wxSize temp2 ;
15812 wxPoint temp3 ;
15813 int val4 ;
15814 int ecode4 = 0 ;
15815 int val5 ;
15816 int ecode5 = 0 ;
15817 int val6 ;
15818 int ecode6 = 0 ;
15819 PyObject * obj0 = 0 ;
15820 PyObject * obj1 = 0 ;
15821 PyObject * obj2 = 0 ;
15822 PyObject * obj3 = 0 ;
15823 PyObject * obj4 = 0 ;
15824 PyObject * obj5 = 0 ;
15825 char * kwnames[] = {
15826 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15827 };
15828
15829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15831 if (!SWIG_IsOK(res1)) {
15832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15833 }
15834 arg1 = reinterpret_cast< wxImage * >(argp1);
15835 {
15836 arg2 = &temp2;
15837 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15838 }
15839 {
15840 arg3 = &temp3;
15841 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15842 }
15843 if (obj3) {
15844 ecode4 = SWIG_AsVal_int(obj3, &val4);
15845 if (!SWIG_IsOK(ecode4)) {
15846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15847 }
15848 arg4 = static_cast< int >(val4);
15849 }
15850 if (obj4) {
15851 ecode5 = SWIG_AsVal_int(obj4, &val5);
15852 if (!SWIG_IsOK(ecode5)) {
15853 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15854 }
15855 arg5 = static_cast< int >(val5);
15856 }
15857 if (obj5) {
15858 ecode6 = SWIG_AsVal_int(obj5, &val6);
15859 if (!SWIG_IsOK(ecode6)) {
15860 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15861 }
15862 arg6 = static_cast< int >(val6);
15863 }
15864 {
15865 PyThreadState* __tstate = wxPyBeginAllowThreads();
15866 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15871 return resultobj;
15872 fail:
15873 return NULL;
15874 }
15875
15876
15877 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15878 PyObject *resultobj = 0;
15879 wxImage *arg1 = (wxImage *) 0 ;
15880 SwigValueWrapper<wxImage > result;
15881 void *argp1 = 0 ;
15882 int res1 = 0 ;
15883 PyObject *swig_obj[1] ;
15884
15885 if (!args) SWIG_fail;
15886 swig_obj[0] = args;
15887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15888 if (!SWIG_IsOK(res1)) {
15889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15890 }
15891 arg1 = reinterpret_cast< wxImage * >(argp1);
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 result = (arg1)->Copy();
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_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15906 PyObject *resultobj = 0;
15907 wxImage *arg1 = (wxImage *) 0 ;
15908 wxImage *arg2 = 0 ;
15909 int arg3 ;
15910 int arg4 ;
15911 void *argp1 = 0 ;
15912 int res1 = 0 ;
15913 void *argp2 = 0 ;
15914 int res2 = 0 ;
15915 int val3 ;
15916 int ecode3 = 0 ;
15917 int val4 ;
15918 int ecode4 = 0 ;
15919 PyObject * obj0 = 0 ;
15920 PyObject * obj1 = 0 ;
15921 PyObject * obj2 = 0 ;
15922 PyObject * obj3 = 0 ;
15923 char * kwnames[] = {
15924 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15925 };
15926
15927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15929 if (!SWIG_IsOK(res1)) {
15930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15931 }
15932 arg1 = reinterpret_cast< wxImage * >(argp1);
15933 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15934 if (!SWIG_IsOK(res2)) {
15935 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15936 }
15937 if (!argp2) {
15938 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15939 }
15940 arg2 = reinterpret_cast< wxImage * >(argp2);
15941 ecode3 = SWIG_AsVal_int(obj2, &val3);
15942 if (!SWIG_IsOK(ecode3)) {
15943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15944 }
15945 arg3 = static_cast< int >(val3);
15946 ecode4 = SWIG_AsVal_int(obj3, &val4);
15947 if (!SWIG_IsOK(ecode4)) {
15948 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15949 }
15950 arg4 = static_cast< int >(val4);
15951 {
15952 PyThreadState* __tstate = wxPyBeginAllowThreads();
15953 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15954 wxPyEndAllowThreads(__tstate);
15955 if (PyErr_Occurred()) SWIG_fail;
15956 }
15957 resultobj = SWIG_Py_Void();
15958 return resultobj;
15959 fail:
15960 return NULL;
15961 }
15962
15963
15964 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15965 PyObject *resultobj = 0;
15966 wxImage *arg1 = (wxImage *) 0 ;
15967 PyObject *result = 0 ;
15968 void *argp1 = 0 ;
15969 int res1 = 0 ;
15970 PyObject *swig_obj[1] ;
15971
15972 if (!args) SWIG_fail;
15973 swig_obj[0] = args;
15974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15975 if (!SWIG_IsOK(res1)) {
15976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15977 }
15978 arg1 = reinterpret_cast< wxImage * >(argp1);
15979 {
15980 PyThreadState* __tstate = wxPyBeginAllowThreads();
15981 result = (PyObject *)wxImage_GetData(arg1);
15982 wxPyEndAllowThreads(__tstate);
15983 if (PyErr_Occurred()) SWIG_fail;
15984 }
15985 resultobj = result;
15986 return resultobj;
15987 fail:
15988 return NULL;
15989 }
15990
15991
15992 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15993 PyObject *resultobj = 0;
15994 wxImage *arg1 = (wxImage *) 0 ;
15995 buffer arg2 ;
15996 int arg3 ;
15997 void *argp1 = 0 ;
15998 int res1 = 0 ;
15999 Py_ssize_t temp2 ;
16000 PyObject * obj0 = 0 ;
16001 PyObject * obj1 = 0 ;
16002 char * kwnames[] = {
16003 (char *) "self",(char *) "data", NULL
16004 };
16005
16006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
16007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16008 if (!SWIG_IsOK(res1)) {
16009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
16010 }
16011 arg1 = reinterpret_cast< wxImage * >(argp1);
16012 {
16013 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16014 arg3 = (int)temp2;
16015 }
16016 {
16017 PyThreadState* __tstate = wxPyBeginAllowThreads();
16018 wxImage_SetData(arg1,arg2,arg3);
16019 wxPyEndAllowThreads(__tstate);
16020 if (PyErr_Occurred()) SWIG_fail;
16021 }
16022 resultobj = SWIG_Py_Void();
16023 return resultobj;
16024 fail:
16025 return NULL;
16026 }
16027
16028
16029 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16030 PyObject *resultobj = 0;
16031 wxImage *arg1 = (wxImage *) 0 ;
16032 PyObject *result = 0 ;
16033 void *argp1 = 0 ;
16034 int res1 = 0 ;
16035 PyObject *swig_obj[1] ;
16036
16037 if (!args) SWIG_fail;
16038 swig_obj[0] = args;
16039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16040 if (!SWIG_IsOK(res1)) {
16041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16042 }
16043 arg1 = reinterpret_cast< wxImage * >(argp1);
16044 {
16045 PyThreadState* __tstate = wxPyBeginAllowThreads();
16046 result = (PyObject *)wxImage_GetDataBuffer(arg1);
16047 wxPyEndAllowThreads(__tstate);
16048 if (PyErr_Occurred()) SWIG_fail;
16049 }
16050 resultobj = result;
16051 return resultobj;
16052 fail:
16053 return NULL;
16054 }
16055
16056
16057 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16058 PyObject *resultobj = 0;
16059 wxImage *arg1 = (wxImage *) 0 ;
16060 buffer arg2 ;
16061 int arg3 ;
16062 void *argp1 = 0 ;
16063 int res1 = 0 ;
16064 Py_ssize_t temp2 ;
16065 PyObject * obj0 = 0 ;
16066 PyObject * obj1 = 0 ;
16067 char * kwnames[] = {
16068 (char *) "self",(char *) "data", NULL
16069 };
16070
16071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16073 if (!SWIG_IsOK(res1)) {
16074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16075 }
16076 arg1 = reinterpret_cast< wxImage * >(argp1);
16077 {
16078 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16079 arg3 = (int)temp2;
16080 }
16081 {
16082 PyThreadState* __tstate = wxPyBeginAllowThreads();
16083 wxImage_SetDataBuffer(arg1,arg2,arg3);
16084 wxPyEndAllowThreads(__tstate);
16085 if (PyErr_Occurred()) SWIG_fail;
16086 }
16087 resultobj = SWIG_Py_Void();
16088 return resultobj;
16089 fail:
16090 return NULL;
16091 }
16092
16093
16094 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16095 PyObject *resultobj = 0;
16096 wxImage *arg1 = (wxImage *) 0 ;
16097 PyObject *result = 0 ;
16098 void *argp1 = 0 ;
16099 int res1 = 0 ;
16100 PyObject *swig_obj[1] ;
16101
16102 if (!args) SWIG_fail;
16103 swig_obj[0] = args;
16104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16105 if (!SWIG_IsOK(res1)) {
16106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16107 }
16108 arg1 = reinterpret_cast< wxImage * >(argp1);
16109 {
16110 PyThreadState* __tstate = wxPyBeginAllowThreads();
16111 result = (PyObject *)wxImage_GetAlphaData(arg1);
16112 wxPyEndAllowThreads(__tstate);
16113 if (PyErr_Occurred()) SWIG_fail;
16114 }
16115 resultobj = result;
16116 return resultobj;
16117 fail:
16118 return NULL;
16119 }
16120
16121
16122 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16123 PyObject *resultobj = 0;
16124 wxImage *arg1 = (wxImage *) 0 ;
16125 buffer arg2 ;
16126 int arg3 ;
16127 void *argp1 = 0 ;
16128 int res1 = 0 ;
16129 Py_ssize_t temp2 ;
16130 PyObject * obj0 = 0 ;
16131 PyObject * obj1 = 0 ;
16132 char * kwnames[] = {
16133 (char *) "self",(char *) "alpha", NULL
16134 };
16135
16136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
16137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16138 if (!SWIG_IsOK(res1)) {
16139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16140 }
16141 arg1 = reinterpret_cast< wxImage * >(argp1);
16142 {
16143 if (obj1 != Py_None) {
16144 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16145 arg3 = (int)temp2;
16146 }
16147 }
16148 {
16149 PyThreadState* __tstate = wxPyBeginAllowThreads();
16150 wxImage_SetAlphaData(arg1,arg2,arg3);
16151 wxPyEndAllowThreads(__tstate);
16152 if (PyErr_Occurred()) SWIG_fail;
16153 }
16154 resultobj = SWIG_Py_Void();
16155 return resultobj;
16156 fail:
16157 return NULL;
16158 }
16159
16160
16161 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16162 PyObject *resultobj = 0;
16163 wxImage *arg1 = (wxImage *) 0 ;
16164 PyObject *result = 0 ;
16165 void *argp1 = 0 ;
16166 int res1 = 0 ;
16167 PyObject *swig_obj[1] ;
16168
16169 if (!args) SWIG_fail;
16170 swig_obj[0] = args;
16171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16172 if (!SWIG_IsOK(res1)) {
16173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16174 }
16175 arg1 = reinterpret_cast< wxImage * >(argp1);
16176 {
16177 PyThreadState* __tstate = wxPyBeginAllowThreads();
16178 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
16179 wxPyEndAllowThreads(__tstate);
16180 if (PyErr_Occurred()) SWIG_fail;
16181 }
16182 resultobj = result;
16183 return resultobj;
16184 fail:
16185 return NULL;
16186 }
16187
16188
16189 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16190 PyObject *resultobj = 0;
16191 wxImage *arg1 = (wxImage *) 0 ;
16192 buffer arg2 ;
16193 int arg3 ;
16194 void *argp1 = 0 ;
16195 int res1 = 0 ;
16196 Py_ssize_t temp2 ;
16197 PyObject * obj0 = 0 ;
16198 PyObject * obj1 = 0 ;
16199 char * kwnames[] = {
16200 (char *) "self",(char *) "alpha", NULL
16201 };
16202
16203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16205 if (!SWIG_IsOK(res1)) {
16206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16207 }
16208 arg1 = reinterpret_cast< wxImage * >(argp1);
16209 {
16210 if (obj1 != Py_None) {
16211 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16212 arg3 = (int)temp2;
16213 }
16214 }
16215 {
16216 PyThreadState* __tstate = wxPyBeginAllowThreads();
16217 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
16218 wxPyEndAllowThreads(__tstate);
16219 if (PyErr_Occurred()) SWIG_fail;
16220 }
16221 resultobj = SWIG_Py_Void();
16222 return resultobj;
16223 fail:
16224 return NULL;
16225 }
16226
16227
16228 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16229 PyObject *resultobj = 0;
16230 wxImage *arg1 = (wxImage *) 0 ;
16231 byte arg2 ;
16232 byte arg3 ;
16233 byte arg4 ;
16234 void *argp1 = 0 ;
16235 int res1 = 0 ;
16236 unsigned char val2 ;
16237 int ecode2 = 0 ;
16238 unsigned char val3 ;
16239 int ecode3 = 0 ;
16240 unsigned char val4 ;
16241 int ecode4 = 0 ;
16242 PyObject * obj0 = 0 ;
16243 PyObject * obj1 = 0 ;
16244 PyObject * obj2 = 0 ;
16245 PyObject * obj3 = 0 ;
16246 char * kwnames[] = {
16247 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16248 };
16249
16250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16252 if (!SWIG_IsOK(res1)) {
16253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
16254 }
16255 arg1 = reinterpret_cast< wxImage * >(argp1);
16256 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16257 if (!SWIG_IsOK(ecode2)) {
16258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
16259 }
16260 arg2 = static_cast< byte >(val2);
16261 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16262 if (!SWIG_IsOK(ecode3)) {
16263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
16264 }
16265 arg3 = static_cast< byte >(val3);
16266 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16267 if (!SWIG_IsOK(ecode4)) {
16268 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
16269 }
16270 arg4 = static_cast< byte >(val4);
16271 {
16272 PyThreadState* __tstate = wxPyBeginAllowThreads();
16273 (arg1)->SetMaskColour(arg2,arg3,arg4);
16274 wxPyEndAllowThreads(__tstate);
16275 if (PyErr_Occurred()) SWIG_fail;
16276 }
16277 resultobj = SWIG_Py_Void();
16278 return resultobj;
16279 fail:
16280 return NULL;
16281 }
16282
16283
16284 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16285 PyObject *resultobj = 0;
16286 wxImage *arg1 = (wxImage *) 0 ;
16287 byte *arg2 = (byte *) 0 ;
16288 byte *arg3 = (byte *) 0 ;
16289 byte *arg4 = (byte *) 0 ;
16290 void *argp1 = 0 ;
16291 int res1 = 0 ;
16292 byte temp2 ;
16293 int res2 = SWIG_TMPOBJ ;
16294 byte temp3 ;
16295 int res3 = SWIG_TMPOBJ ;
16296 byte temp4 ;
16297 int res4 = SWIG_TMPOBJ ;
16298 PyObject *swig_obj[1] ;
16299
16300 arg2 = &temp2;
16301 arg3 = &temp3;
16302 arg4 = &temp4;
16303 if (!args) SWIG_fail;
16304 swig_obj[0] = args;
16305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16306 if (!SWIG_IsOK(res1)) {
16307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
16308 }
16309 arg1 = reinterpret_cast< wxImage * >(argp1);
16310 {
16311 PyThreadState* __tstate = wxPyBeginAllowThreads();
16312 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
16313 wxPyEndAllowThreads(__tstate);
16314 if (PyErr_Occurred()) SWIG_fail;
16315 }
16316 resultobj = SWIG_Py_Void();
16317 if (SWIG_IsTmpObj(res2)) {
16318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
16319 } else {
16320 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16321 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
16322 }
16323 if (SWIG_IsTmpObj(res3)) {
16324 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
16325 } else {
16326 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
16328 }
16329 if (SWIG_IsTmpObj(res4)) {
16330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
16331 } else {
16332 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
16334 }
16335 return resultobj;
16336 fail:
16337 return NULL;
16338 }
16339
16340
16341 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16342 PyObject *resultobj = 0;
16343 wxImage *arg1 = (wxImage *) 0 ;
16344 byte result;
16345 void *argp1 = 0 ;
16346 int res1 = 0 ;
16347 PyObject *swig_obj[1] ;
16348
16349 if (!args) SWIG_fail;
16350 swig_obj[0] = args;
16351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16352 if (!SWIG_IsOK(res1)) {
16353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
16354 }
16355 arg1 = reinterpret_cast< wxImage * >(argp1);
16356 {
16357 PyThreadState* __tstate = wxPyBeginAllowThreads();
16358 result = (byte)(arg1)->GetMaskRed();
16359 wxPyEndAllowThreads(__tstate);
16360 if (PyErr_Occurred()) SWIG_fail;
16361 }
16362 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16363 return resultobj;
16364 fail:
16365 return NULL;
16366 }
16367
16368
16369 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(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_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16382 }
16383 arg1 = reinterpret_cast< wxImage * >(argp1);
16384 {
16385 PyThreadState* __tstate = wxPyBeginAllowThreads();
16386 result = (byte)(arg1)->GetMaskGreen();
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_GetMaskBlue(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_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16410 }
16411 arg1 = reinterpret_cast< wxImage * >(argp1);
16412 {
16413 PyThreadState* __tstate = wxPyBeginAllowThreads();
16414 result = (byte)(arg1)->GetMaskBlue();
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_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16426 PyObject *resultobj = 0;
16427 wxImage *arg1 = (wxImage *) 0 ;
16428 bool arg2 = (bool) true ;
16429 void *argp1 = 0 ;
16430 int res1 = 0 ;
16431 bool val2 ;
16432 int ecode2 = 0 ;
16433 PyObject * obj0 = 0 ;
16434 PyObject * obj1 = 0 ;
16435 char * kwnames[] = {
16436 (char *) "self",(char *) "mask", NULL
16437 };
16438
16439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
16440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16441 if (!SWIG_IsOK(res1)) {
16442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16443 }
16444 arg1 = reinterpret_cast< wxImage * >(argp1);
16445 if (obj1) {
16446 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16447 if (!SWIG_IsOK(ecode2)) {
16448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16449 }
16450 arg2 = static_cast< bool >(val2);
16451 }
16452 {
16453 PyThreadState* __tstate = wxPyBeginAllowThreads();
16454 (arg1)->SetMask(arg2);
16455 wxPyEndAllowThreads(__tstate);
16456 if (PyErr_Occurred()) SWIG_fail;
16457 }
16458 resultobj = SWIG_Py_Void();
16459 return resultobj;
16460 fail:
16461 return NULL;
16462 }
16463
16464
16465 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16466 PyObject *resultobj = 0;
16467 wxImage *arg1 = (wxImage *) 0 ;
16468 bool result;
16469 void *argp1 = 0 ;
16470 int res1 = 0 ;
16471 PyObject *swig_obj[1] ;
16472
16473 if (!args) SWIG_fail;
16474 swig_obj[0] = args;
16475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16476 if (!SWIG_IsOK(res1)) {
16477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16478 }
16479 arg1 = reinterpret_cast< wxImage * >(argp1);
16480 {
16481 PyThreadState* __tstate = wxPyBeginAllowThreads();
16482 result = (bool)(arg1)->HasMask();
16483 wxPyEndAllowThreads(__tstate);
16484 if (PyErr_Occurred()) SWIG_fail;
16485 }
16486 {
16487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16488 }
16489 return resultobj;
16490 fail:
16491 return NULL;
16492 }
16493
16494
16495 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16496 PyObject *resultobj = 0;
16497 wxImage *arg1 = (wxImage *) 0 ;
16498 double arg2 ;
16499 wxPoint *arg3 = 0 ;
16500 bool arg4 = (bool) true ;
16501 wxPoint *arg5 = (wxPoint *) NULL ;
16502 SwigValueWrapper<wxImage > result;
16503 void *argp1 = 0 ;
16504 int res1 = 0 ;
16505 double val2 ;
16506 int ecode2 = 0 ;
16507 wxPoint temp3 ;
16508 bool val4 ;
16509 int ecode4 = 0 ;
16510 void *argp5 = 0 ;
16511 int res5 = 0 ;
16512 PyObject * obj0 = 0 ;
16513 PyObject * obj1 = 0 ;
16514 PyObject * obj2 = 0 ;
16515 PyObject * obj3 = 0 ;
16516 PyObject * obj4 = 0 ;
16517 char * kwnames[] = {
16518 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16519 };
16520
16521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16523 if (!SWIG_IsOK(res1)) {
16524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16525 }
16526 arg1 = reinterpret_cast< wxImage * >(argp1);
16527 ecode2 = SWIG_AsVal_double(obj1, &val2);
16528 if (!SWIG_IsOK(ecode2)) {
16529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16530 }
16531 arg2 = static_cast< double >(val2);
16532 {
16533 arg3 = &temp3;
16534 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16535 }
16536 if (obj3) {
16537 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16538 if (!SWIG_IsOK(ecode4)) {
16539 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16540 }
16541 arg4 = static_cast< bool >(val4);
16542 }
16543 if (obj4) {
16544 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16545 if (!SWIG_IsOK(res5)) {
16546 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16547 }
16548 arg5 = reinterpret_cast< wxPoint * >(argp5);
16549 }
16550 {
16551 PyThreadState* __tstate = wxPyBeginAllowThreads();
16552 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16553 wxPyEndAllowThreads(__tstate);
16554 if (PyErr_Occurred()) SWIG_fail;
16555 }
16556 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16557 return resultobj;
16558 fail:
16559 return NULL;
16560 }
16561
16562
16563 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16564 PyObject *resultobj = 0;
16565 wxImage *arg1 = (wxImage *) 0 ;
16566 bool arg2 = (bool) true ;
16567 SwigValueWrapper<wxImage > result;
16568 void *argp1 = 0 ;
16569 int res1 = 0 ;
16570 bool val2 ;
16571 int ecode2 = 0 ;
16572 PyObject * obj0 = 0 ;
16573 PyObject * obj1 = 0 ;
16574 char * kwnames[] = {
16575 (char *) "self",(char *) "clockwise", NULL
16576 };
16577
16578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16580 if (!SWIG_IsOK(res1)) {
16581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16582 }
16583 arg1 = reinterpret_cast< wxImage * >(argp1);
16584 if (obj1) {
16585 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16586 if (!SWIG_IsOK(ecode2)) {
16587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16588 }
16589 arg2 = static_cast< bool >(val2);
16590 }
16591 {
16592 PyThreadState* __tstate = wxPyBeginAllowThreads();
16593 result = (arg1)->Rotate90(arg2);
16594 wxPyEndAllowThreads(__tstate);
16595 if (PyErr_Occurred()) SWIG_fail;
16596 }
16597 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16598 return resultobj;
16599 fail:
16600 return NULL;
16601 }
16602
16603
16604 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16605 PyObject *resultobj = 0;
16606 wxImage *arg1 = (wxImage *) 0 ;
16607 bool arg2 = (bool) true ;
16608 SwigValueWrapper<wxImage > result;
16609 void *argp1 = 0 ;
16610 int res1 = 0 ;
16611 bool val2 ;
16612 int ecode2 = 0 ;
16613 PyObject * obj0 = 0 ;
16614 PyObject * obj1 = 0 ;
16615 char * kwnames[] = {
16616 (char *) "self",(char *) "horizontally", NULL
16617 };
16618
16619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16621 if (!SWIG_IsOK(res1)) {
16622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16623 }
16624 arg1 = reinterpret_cast< wxImage * >(argp1);
16625 if (obj1) {
16626 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16627 if (!SWIG_IsOK(ecode2)) {
16628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16629 }
16630 arg2 = static_cast< bool >(val2);
16631 }
16632 {
16633 PyThreadState* __tstate = wxPyBeginAllowThreads();
16634 result = (arg1)->Mirror(arg2);
16635 wxPyEndAllowThreads(__tstate);
16636 if (PyErr_Occurred()) SWIG_fail;
16637 }
16638 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16639 return resultobj;
16640 fail:
16641 return NULL;
16642 }
16643
16644
16645 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16646 PyObject *resultobj = 0;
16647 wxImage *arg1 = (wxImage *) 0 ;
16648 byte arg2 ;
16649 byte arg3 ;
16650 byte arg4 ;
16651 byte arg5 ;
16652 byte arg6 ;
16653 byte arg7 ;
16654 void *argp1 = 0 ;
16655 int res1 = 0 ;
16656 unsigned char val2 ;
16657 int ecode2 = 0 ;
16658 unsigned char val3 ;
16659 int ecode3 = 0 ;
16660 unsigned char val4 ;
16661 int ecode4 = 0 ;
16662 unsigned char val5 ;
16663 int ecode5 = 0 ;
16664 unsigned char val6 ;
16665 int ecode6 = 0 ;
16666 unsigned char val7 ;
16667 int ecode7 = 0 ;
16668 PyObject * obj0 = 0 ;
16669 PyObject * obj1 = 0 ;
16670 PyObject * obj2 = 0 ;
16671 PyObject * obj3 = 0 ;
16672 PyObject * obj4 = 0 ;
16673 PyObject * obj5 = 0 ;
16674 PyObject * obj6 = 0 ;
16675 char * kwnames[] = {
16676 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16677 };
16678
16679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16681 if (!SWIG_IsOK(res1)) {
16682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16683 }
16684 arg1 = reinterpret_cast< wxImage * >(argp1);
16685 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16686 if (!SWIG_IsOK(ecode2)) {
16687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16688 }
16689 arg2 = static_cast< byte >(val2);
16690 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16691 if (!SWIG_IsOK(ecode3)) {
16692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16693 }
16694 arg3 = static_cast< byte >(val3);
16695 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16696 if (!SWIG_IsOK(ecode4)) {
16697 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16698 }
16699 arg4 = static_cast< byte >(val4);
16700 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16701 if (!SWIG_IsOK(ecode5)) {
16702 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16703 }
16704 arg5 = static_cast< byte >(val5);
16705 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16706 if (!SWIG_IsOK(ecode6)) {
16707 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16708 }
16709 arg6 = static_cast< byte >(val6);
16710 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16711 if (!SWIG_IsOK(ecode7)) {
16712 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16713 }
16714 arg7 = static_cast< byte >(val7);
16715 {
16716 PyThreadState* __tstate = wxPyBeginAllowThreads();
16717 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16718 wxPyEndAllowThreads(__tstate);
16719 if (PyErr_Occurred()) SWIG_fail;
16720 }
16721 resultobj = SWIG_Py_Void();
16722 return resultobj;
16723 fail:
16724 return NULL;
16725 }
16726
16727
16728 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16729 PyObject *resultobj = 0;
16730 wxImage *arg1 = (wxImage *) 0 ;
16731 double arg2 = (double) 0.299 ;
16732 double arg3 = (double) 0.587 ;
16733 double arg4 = (double) 0.114 ;
16734 SwigValueWrapper<wxImage > result;
16735 void *argp1 = 0 ;
16736 int res1 = 0 ;
16737 double val2 ;
16738 int ecode2 = 0 ;
16739 double val3 ;
16740 int ecode3 = 0 ;
16741 double val4 ;
16742 int ecode4 = 0 ;
16743 PyObject * obj0 = 0 ;
16744 PyObject * obj1 = 0 ;
16745 PyObject * obj2 = 0 ;
16746 PyObject * obj3 = 0 ;
16747 char * kwnames[] = {
16748 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16749 };
16750
16751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16753 if (!SWIG_IsOK(res1)) {
16754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16755 }
16756 arg1 = reinterpret_cast< wxImage * >(argp1);
16757 if (obj1) {
16758 ecode2 = SWIG_AsVal_double(obj1, &val2);
16759 if (!SWIG_IsOK(ecode2)) {
16760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16761 }
16762 arg2 = static_cast< double >(val2);
16763 }
16764 if (obj2) {
16765 ecode3 = SWIG_AsVal_double(obj2, &val3);
16766 if (!SWIG_IsOK(ecode3)) {
16767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16768 }
16769 arg3 = static_cast< double >(val3);
16770 }
16771 if (obj3) {
16772 ecode4 = SWIG_AsVal_double(obj3, &val4);
16773 if (!SWIG_IsOK(ecode4)) {
16774 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16775 }
16776 arg4 = static_cast< double >(val4);
16777 }
16778 {
16779 PyThreadState* __tstate = wxPyBeginAllowThreads();
16780 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16781 wxPyEndAllowThreads(__tstate);
16782 if (PyErr_Occurred()) SWIG_fail;
16783 }
16784 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16785 return resultobj;
16786 fail:
16787 return NULL;
16788 }
16789
16790
16791 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16792 PyObject *resultobj = 0;
16793 wxImage *arg1 = (wxImage *) 0 ;
16794 byte arg2 ;
16795 byte arg3 ;
16796 byte arg4 ;
16797 SwigValueWrapper<wxImage > result;
16798 void *argp1 = 0 ;
16799 int res1 = 0 ;
16800 unsigned char val2 ;
16801 int ecode2 = 0 ;
16802 unsigned char val3 ;
16803 int ecode3 = 0 ;
16804 unsigned char val4 ;
16805 int ecode4 = 0 ;
16806 PyObject * obj0 = 0 ;
16807 PyObject * obj1 = 0 ;
16808 PyObject * obj2 = 0 ;
16809 PyObject * obj3 = 0 ;
16810 char * kwnames[] = {
16811 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16812 };
16813
16814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16816 if (!SWIG_IsOK(res1)) {
16817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16818 }
16819 arg1 = reinterpret_cast< wxImage * >(argp1);
16820 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16821 if (!SWIG_IsOK(ecode2)) {
16822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16823 }
16824 arg2 = static_cast< byte >(val2);
16825 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16826 if (!SWIG_IsOK(ecode3)) {
16827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16828 }
16829 arg3 = static_cast< byte >(val3);
16830 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16831 if (!SWIG_IsOK(ecode4)) {
16832 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16833 }
16834 arg4 = static_cast< byte >(val4);
16835 {
16836 PyThreadState* __tstate = wxPyBeginAllowThreads();
16837 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16838 wxPyEndAllowThreads(__tstate);
16839 if (PyErr_Occurred()) SWIG_fail;
16840 }
16841 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16842 return resultobj;
16843 fail:
16844 return NULL;
16845 }
16846
16847
16848 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16849 PyObject *resultobj = 0;
16850 wxImage *arg1 = (wxImage *) 0 ;
16851 wxString *arg2 = 0 ;
16852 wxString *arg3 = 0 ;
16853 void *argp1 = 0 ;
16854 int res1 = 0 ;
16855 bool temp2 = false ;
16856 bool temp3 = false ;
16857 PyObject * obj0 = 0 ;
16858 PyObject * obj1 = 0 ;
16859 PyObject * obj2 = 0 ;
16860 char * kwnames[] = {
16861 (char *) "self",(char *) "name",(char *) "value", NULL
16862 };
16863
16864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16866 if (!SWIG_IsOK(res1)) {
16867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16868 }
16869 arg1 = reinterpret_cast< wxImage * >(argp1);
16870 {
16871 arg2 = wxString_in_helper(obj1);
16872 if (arg2 == NULL) SWIG_fail;
16873 temp2 = true;
16874 }
16875 {
16876 arg3 = wxString_in_helper(obj2);
16877 if (arg3 == NULL) SWIG_fail;
16878 temp3 = true;
16879 }
16880 {
16881 PyThreadState* __tstate = wxPyBeginAllowThreads();
16882 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16883 wxPyEndAllowThreads(__tstate);
16884 if (PyErr_Occurred()) SWIG_fail;
16885 }
16886 resultobj = SWIG_Py_Void();
16887 {
16888 if (temp2)
16889 delete arg2;
16890 }
16891 {
16892 if (temp3)
16893 delete arg3;
16894 }
16895 return resultobj;
16896 fail:
16897 {
16898 if (temp2)
16899 delete arg2;
16900 }
16901 {
16902 if (temp3)
16903 delete arg3;
16904 }
16905 return NULL;
16906 }
16907
16908
16909 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16910 PyObject *resultobj = 0;
16911 wxImage *arg1 = (wxImage *) 0 ;
16912 wxString *arg2 = 0 ;
16913 int arg3 ;
16914 void *argp1 = 0 ;
16915 int res1 = 0 ;
16916 bool temp2 = false ;
16917 int val3 ;
16918 int ecode3 = 0 ;
16919 PyObject * obj0 = 0 ;
16920 PyObject * obj1 = 0 ;
16921 PyObject * obj2 = 0 ;
16922 char * kwnames[] = {
16923 (char *) "self",(char *) "name",(char *) "value", NULL
16924 };
16925
16926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16928 if (!SWIG_IsOK(res1)) {
16929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16930 }
16931 arg1 = reinterpret_cast< wxImage * >(argp1);
16932 {
16933 arg2 = wxString_in_helper(obj1);
16934 if (arg2 == NULL) SWIG_fail;
16935 temp2 = true;
16936 }
16937 ecode3 = SWIG_AsVal_int(obj2, &val3);
16938 if (!SWIG_IsOK(ecode3)) {
16939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16940 }
16941 arg3 = static_cast< int >(val3);
16942 {
16943 PyThreadState* __tstate = wxPyBeginAllowThreads();
16944 (arg1)->SetOption((wxString const &)*arg2,arg3);
16945 wxPyEndAllowThreads(__tstate);
16946 if (PyErr_Occurred()) SWIG_fail;
16947 }
16948 resultobj = SWIG_Py_Void();
16949 {
16950 if (temp2)
16951 delete arg2;
16952 }
16953 return resultobj;
16954 fail:
16955 {
16956 if (temp2)
16957 delete arg2;
16958 }
16959 return NULL;
16960 }
16961
16962
16963 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16964 PyObject *resultobj = 0;
16965 wxImage *arg1 = (wxImage *) 0 ;
16966 wxString *arg2 = 0 ;
16967 wxString result;
16968 void *argp1 = 0 ;
16969 int res1 = 0 ;
16970 bool temp2 = false ;
16971 PyObject * obj0 = 0 ;
16972 PyObject * obj1 = 0 ;
16973 char * kwnames[] = {
16974 (char *) "self",(char *) "name", NULL
16975 };
16976
16977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16979 if (!SWIG_IsOK(res1)) {
16980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16981 }
16982 arg1 = reinterpret_cast< wxImage * >(argp1);
16983 {
16984 arg2 = wxString_in_helper(obj1);
16985 if (arg2 == NULL) SWIG_fail;
16986 temp2 = true;
16987 }
16988 {
16989 PyThreadState* __tstate = wxPyBeginAllowThreads();
16990 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16991 wxPyEndAllowThreads(__tstate);
16992 if (PyErr_Occurred()) SWIG_fail;
16993 }
16994 {
16995 #if wxUSE_UNICODE
16996 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16997 #else
16998 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16999 #endif
17000 }
17001 {
17002 if (temp2)
17003 delete arg2;
17004 }
17005 return resultobj;
17006 fail:
17007 {
17008 if (temp2)
17009 delete arg2;
17010 }
17011 return NULL;
17012 }
17013
17014
17015 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17016 PyObject *resultobj = 0;
17017 wxImage *arg1 = (wxImage *) 0 ;
17018 wxString *arg2 = 0 ;
17019 int result;
17020 void *argp1 = 0 ;
17021 int res1 = 0 ;
17022 bool temp2 = false ;
17023 PyObject * obj0 = 0 ;
17024 PyObject * obj1 = 0 ;
17025 char * kwnames[] = {
17026 (char *) "self",(char *) "name", NULL
17027 };
17028
17029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
17030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17031 if (!SWIG_IsOK(res1)) {
17032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
17033 }
17034 arg1 = reinterpret_cast< wxImage * >(argp1);
17035 {
17036 arg2 = wxString_in_helper(obj1);
17037 if (arg2 == NULL) SWIG_fail;
17038 temp2 = true;
17039 }
17040 {
17041 PyThreadState* __tstate = wxPyBeginAllowThreads();
17042 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
17043 wxPyEndAllowThreads(__tstate);
17044 if (PyErr_Occurred()) SWIG_fail;
17045 }
17046 resultobj = SWIG_From_int(static_cast< int >(result));
17047 {
17048 if (temp2)
17049 delete arg2;
17050 }
17051 return resultobj;
17052 fail:
17053 {
17054 if (temp2)
17055 delete arg2;
17056 }
17057 return NULL;
17058 }
17059
17060
17061 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17062 PyObject *resultobj = 0;
17063 wxImage *arg1 = (wxImage *) 0 ;
17064 wxString *arg2 = 0 ;
17065 bool result;
17066 void *argp1 = 0 ;
17067 int res1 = 0 ;
17068 bool temp2 = false ;
17069 PyObject * obj0 = 0 ;
17070 PyObject * obj1 = 0 ;
17071 char * kwnames[] = {
17072 (char *) "self",(char *) "name", NULL
17073 };
17074
17075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
17076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17077 if (!SWIG_IsOK(res1)) {
17078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17079 }
17080 arg1 = reinterpret_cast< wxImage * >(argp1);
17081 {
17082 arg2 = wxString_in_helper(obj1);
17083 if (arg2 == NULL) SWIG_fail;
17084 temp2 = true;
17085 }
17086 {
17087 PyThreadState* __tstate = wxPyBeginAllowThreads();
17088 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
17089 wxPyEndAllowThreads(__tstate);
17090 if (PyErr_Occurred()) SWIG_fail;
17091 }
17092 {
17093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17094 }
17095 {
17096 if (temp2)
17097 delete arg2;
17098 }
17099 return resultobj;
17100 fail:
17101 {
17102 if (temp2)
17103 delete arg2;
17104 }
17105 return NULL;
17106 }
17107
17108
17109 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17110 PyObject *resultobj = 0;
17111 wxImage *arg1 = (wxImage *) 0 ;
17112 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
17113 unsigned long result;
17114 void *argp1 = 0 ;
17115 int res1 = 0 ;
17116 unsigned long val2 ;
17117 int ecode2 = 0 ;
17118 PyObject * obj0 = 0 ;
17119 PyObject * obj1 = 0 ;
17120 char * kwnames[] = {
17121 (char *) "self",(char *) "stopafter", NULL
17122 };
17123
17124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
17125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17126 if (!SWIG_IsOK(res1)) {
17127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
17128 }
17129 arg1 = reinterpret_cast< wxImage * >(argp1);
17130 if (obj1) {
17131 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
17132 if (!SWIG_IsOK(ecode2)) {
17133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
17134 }
17135 arg2 = static_cast< unsigned long >(val2);
17136 }
17137 {
17138 PyThreadState* __tstate = wxPyBeginAllowThreads();
17139 result = (unsigned long)(arg1)->CountColours(arg2);
17140 wxPyEndAllowThreads(__tstate);
17141 if (PyErr_Occurred()) SWIG_fail;
17142 }
17143 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17144 return resultobj;
17145 fail:
17146 return NULL;
17147 }
17148
17149
17150 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17151 PyObject *resultobj = 0;
17152 wxImage *arg1 = (wxImage *) 0 ;
17153 wxImageHistogram *arg2 = 0 ;
17154 unsigned long result;
17155 void *argp1 = 0 ;
17156 int res1 = 0 ;
17157 void *argp2 = 0 ;
17158 int res2 = 0 ;
17159 PyObject * obj0 = 0 ;
17160 PyObject * obj1 = 0 ;
17161 char * kwnames[] = {
17162 (char *) "self",(char *) "h", NULL
17163 };
17164
17165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
17166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17167 if (!SWIG_IsOK(res1)) {
17168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
17169 }
17170 arg1 = reinterpret_cast< wxImage * >(argp1);
17171 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
17172 if (!SWIG_IsOK(res2)) {
17173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17174 }
17175 if (!argp2) {
17176 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17177 }
17178 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
17179 {
17180 PyThreadState* __tstate = wxPyBeginAllowThreads();
17181 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
17182 wxPyEndAllowThreads(__tstate);
17183 if (PyErr_Occurred()) SWIG_fail;
17184 }
17185 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17186 return resultobj;
17187 fail:
17188 return NULL;
17189 }
17190
17191
17192 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17193 PyObject *resultobj = 0;
17194 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17195 void *argp1 = 0 ;
17196 int res1 = 0 ;
17197 PyObject * obj0 = 0 ;
17198 char * kwnames[] = {
17199 (char *) "handler", NULL
17200 };
17201
17202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
17203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17204 if (!SWIG_IsOK(res1)) {
17205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17206 }
17207 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17208 {
17209 PyThreadState* __tstate = wxPyBeginAllowThreads();
17210 wxImage::AddHandler(arg1);
17211 wxPyEndAllowThreads(__tstate);
17212 if (PyErr_Occurred()) SWIG_fail;
17213 }
17214 resultobj = SWIG_Py_Void();
17215 return resultobj;
17216 fail:
17217 return NULL;
17218 }
17219
17220
17221 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17222 PyObject *resultobj = 0;
17223 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17224 void *argp1 = 0 ;
17225 int res1 = 0 ;
17226 PyObject * obj0 = 0 ;
17227 char * kwnames[] = {
17228 (char *) "handler", NULL
17229 };
17230
17231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
17232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17233 if (!SWIG_IsOK(res1)) {
17234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17235 }
17236 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17237 {
17238 PyThreadState* __tstate = wxPyBeginAllowThreads();
17239 wxImage::InsertHandler(arg1);
17240 wxPyEndAllowThreads(__tstate);
17241 if (PyErr_Occurred()) SWIG_fail;
17242 }
17243 resultobj = SWIG_Py_Void();
17244 return resultobj;
17245 fail:
17246 return NULL;
17247 }
17248
17249
17250 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17251 PyObject *resultobj = 0;
17252 wxString *arg1 = 0 ;
17253 bool result;
17254 bool temp1 = false ;
17255 PyObject * obj0 = 0 ;
17256 char * kwnames[] = {
17257 (char *) "name", NULL
17258 };
17259
17260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
17261 {
17262 arg1 = wxString_in_helper(obj0);
17263 if (arg1 == NULL) SWIG_fail;
17264 temp1 = true;
17265 }
17266 {
17267 PyThreadState* __tstate = wxPyBeginAllowThreads();
17268 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
17269 wxPyEndAllowThreads(__tstate);
17270 if (PyErr_Occurred()) SWIG_fail;
17271 }
17272 {
17273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17274 }
17275 {
17276 if (temp1)
17277 delete arg1;
17278 }
17279 return resultobj;
17280 fail:
17281 {
17282 if (temp1)
17283 delete arg1;
17284 }
17285 return NULL;
17286 }
17287
17288
17289 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17290 PyObject *resultobj = 0;
17291 PyObject *result = 0 ;
17292
17293 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
17294 {
17295 PyThreadState* __tstate = wxPyBeginAllowThreads();
17296 result = (PyObject *)wxImage_GetHandlers();
17297 wxPyEndAllowThreads(__tstate);
17298 if (PyErr_Occurred()) SWIG_fail;
17299 }
17300 resultobj = result;
17301 return resultobj;
17302 fail:
17303 return NULL;
17304 }
17305
17306
17307 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17308 PyObject *resultobj = 0;
17309 wxString result;
17310
17311 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
17312 {
17313 PyThreadState* __tstate = wxPyBeginAllowThreads();
17314 result = wxImage::GetImageExtWildcard();
17315 wxPyEndAllowThreads(__tstate);
17316 if (PyErr_Occurred()) SWIG_fail;
17317 }
17318 {
17319 #if wxUSE_UNICODE
17320 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17321 #else
17322 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17323 #endif
17324 }
17325 return resultobj;
17326 fail:
17327 return NULL;
17328 }
17329
17330
17331 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17332 PyObject *resultobj = 0;
17333 wxImage *arg1 = (wxImage *) 0 ;
17334 int arg2 = (int) -1 ;
17335 wxBitmap result;
17336 void *argp1 = 0 ;
17337 int res1 = 0 ;
17338 int val2 ;
17339 int ecode2 = 0 ;
17340 PyObject * obj0 = 0 ;
17341 PyObject * obj1 = 0 ;
17342 char * kwnames[] = {
17343 (char *) "self",(char *) "depth", NULL
17344 };
17345
17346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
17347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17348 if (!SWIG_IsOK(res1)) {
17349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17350 }
17351 arg1 = reinterpret_cast< wxImage * >(argp1);
17352 if (obj1) {
17353 ecode2 = SWIG_AsVal_int(obj1, &val2);
17354 if (!SWIG_IsOK(ecode2)) {
17355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
17356 }
17357 arg2 = static_cast< int >(val2);
17358 }
17359 {
17360 if (!wxPyCheckForApp()) SWIG_fail;
17361 PyThreadState* __tstate = wxPyBeginAllowThreads();
17362 result = wxImage_ConvertToBitmap(arg1,arg2);
17363 wxPyEndAllowThreads(__tstate);
17364 if (PyErr_Occurred()) SWIG_fail;
17365 }
17366 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17367 return resultobj;
17368 fail:
17369 return NULL;
17370 }
17371
17372
17373 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17374 PyObject *resultobj = 0;
17375 wxImage *arg1 = (wxImage *) 0 ;
17376 byte arg2 ;
17377 byte arg3 ;
17378 byte arg4 ;
17379 wxBitmap result;
17380 void *argp1 = 0 ;
17381 int res1 = 0 ;
17382 unsigned char val2 ;
17383 int ecode2 = 0 ;
17384 unsigned char val3 ;
17385 int ecode3 = 0 ;
17386 unsigned char val4 ;
17387 int ecode4 = 0 ;
17388 PyObject * obj0 = 0 ;
17389 PyObject * obj1 = 0 ;
17390 PyObject * obj2 = 0 ;
17391 PyObject * obj3 = 0 ;
17392 char * kwnames[] = {
17393 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
17394 };
17395
17396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17398 if (!SWIG_IsOK(res1)) {
17399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17400 }
17401 arg1 = reinterpret_cast< wxImage * >(argp1);
17402 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17403 if (!SWIG_IsOK(ecode2)) {
17404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
17405 }
17406 arg2 = static_cast< byte >(val2);
17407 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17408 if (!SWIG_IsOK(ecode3)) {
17409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
17410 }
17411 arg3 = static_cast< byte >(val3);
17412 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17413 if (!SWIG_IsOK(ecode4)) {
17414 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
17415 }
17416 arg4 = static_cast< byte >(val4);
17417 {
17418 if (!wxPyCheckForApp()) SWIG_fail;
17419 PyThreadState* __tstate = wxPyBeginAllowThreads();
17420 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
17421 wxPyEndAllowThreads(__tstate);
17422 if (PyErr_Occurred()) SWIG_fail;
17423 }
17424 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17425 return resultobj;
17426 fail:
17427 return NULL;
17428 }
17429
17430
17431 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17432 PyObject *resultobj = 0;
17433 wxImage *arg1 = (wxImage *) 0 ;
17434 double arg2 ;
17435 void *argp1 = 0 ;
17436 int res1 = 0 ;
17437 double val2 ;
17438 int ecode2 = 0 ;
17439 PyObject * obj0 = 0 ;
17440 PyObject * obj1 = 0 ;
17441 char * kwnames[] = {
17442 (char *) "self",(char *) "angle", NULL
17443 };
17444
17445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17447 if (!SWIG_IsOK(res1)) {
17448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17449 }
17450 arg1 = reinterpret_cast< wxImage * >(argp1);
17451 ecode2 = SWIG_AsVal_double(obj1, &val2);
17452 if (!SWIG_IsOK(ecode2)) {
17453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17454 }
17455 arg2 = static_cast< double >(val2);
17456 {
17457 PyThreadState* __tstate = wxPyBeginAllowThreads();
17458 (arg1)->RotateHue(arg2);
17459 wxPyEndAllowThreads(__tstate);
17460 if (PyErr_Occurred()) SWIG_fail;
17461 }
17462 resultobj = SWIG_Py_Void();
17463 return resultobj;
17464 fail:
17465 return NULL;
17466 }
17467
17468
17469 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17470 PyObject *resultobj = 0;
17471 wxImage_RGBValue arg1 ;
17472 wxImage_HSVValue result;
17473 void *argp1 ;
17474 int res1 = 0 ;
17475 PyObject * obj0 = 0 ;
17476 char * kwnames[] = {
17477 (char *) "rgb", NULL
17478 };
17479
17480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17481 {
17482 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17483 if (!SWIG_IsOK(res1)) {
17484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17485 }
17486 if (!argp1) {
17487 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17488 } else {
17489 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17490 arg1 = *temp;
17491 if (SWIG_IsNewObj(res1)) delete temp;
17492 }
17493 }
17494 {
17495 PyThreadState* __tstate = wxPyBeginAllowThreads();
17496 result = wxImage::RGBtoHSV(arg1);
17497 wxPyEndAllowThreads(__tstate);
17498 if (PyErr_Occurred()) SWIG_fail;
17499 }
17500 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17501 return resultobj;
17502 fail:
17503 return NULL;
17504 }
17505
17506
17507 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17508 PyObject *resultobj = 0;
17509 wxImage_HSVValue arg1 ;
17510 wxImage_RGBValue result;
17511 void *argp1 ;
17512 int res1 = 0 ;
17513 PyObject * obj0 = 0 ;
17514 char * kwnames[] = {
17515 (char *) "hsv", NULL
17516 };
17517
17518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17519 {
17520 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17521 if (!SWIG_IsOK(res1)) {
17522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17523 }
17524 if (!argp1) {
17525 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17526 } else {
17527 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17528 arg1 = *temp;
17529 if (SWIG_IsNewObj(res1)) delete temp;
17530 }
17531 }
17532 {
17533 PyThreadState* __tstate = wxPyBeginAllowThreads();
17534 result = wxImage::HSVtoRGB(arg1);
17535 wxPyEndAllowThreads(__tstate);
17536 if (PyErr_Occurred()) SWIG_fail;
17537 }
17538 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17539 return resultobj;
17540 fail:
17541 return NULL;
17542 }
17543
17544
17545 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17546 PyObject *obj;
17547 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17548 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17549 return SWIG_Py_Void();
17550 }
17551
17552 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17553 return SWIG_Python_InitShadowInstance(args);
17554 }
17555
17556 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17557 PyObject *resultobj = 0;
17558 int arg1 ;
17559 int arg2 ;
17560 buffer arg3 ;
17561 int arg4 ;
17562 buffer arg5 = (buffer) NULL ;
17563 int arg6 = (int) 0 ;
17564 wxImage *result = 0 ;
17565 int val1 ;
17566 int ecode1 = 0 ;
17567 int val2 ;
17568 int ecode2 = 0 ;
17569 Py_ssize_t temp3 ;
17570 Py_ssize_t temp5 ;
17571 PyObject * obj0 = 0 ;
17572 PyObject * obj1 = 0 ;
17573 PyObject * obj2 = 0 ;
17574 PyObject * obj3 = 0 ;
17575 char * kwnames[] = {
17576 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17577 };
17578
17579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17580 ecode1 = SWIG_AsVal_int(obj0, &val1);
17581 if (!SWIG_IsOK(ecode1)) {
17582 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17583 }
17584 arg1 = static_cast< int >(val1);
17585 ecode2 = SWIG_AsVal_int(obj1, &val2);
17586 if (!SWIG_IsOK(ecode2)) {
17587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17588 }
17589 arg2 = static_cast< int >(val2);
17590 {
17591 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17592 arg4 = (int)temp3;
17593 }
17594 if (obj3) {
17595 {
17596 if (obj3 != Py_None) {
17597 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17598 arg6 = (int)temp5;
17599 }
17600 }
17601 }
17602 {
17603 PyThreadState* __tstate = wxPyBeginAllowThreads();
17604 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17605 wxPyEndAllowThreads(__tstate);
17606 if (PyErr_Occurred()) SWIG_fail;
17607 }
17608 {
17609 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17610 }
17611 return resultobj;
17612 fail:
17613 return NULL;
17614 }
17615
17616
17617 SWIGINTERN int NullImage_set(PyObject *) {
17618 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17619 return 1;
17620 }
17621
17622
17623 SWIGINTERN PyObject *NullImage_get(void) {
17624 PyObject *pyobj = 0;
17625
17626 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17627 return pyobj;
17628 }
17629
17630
17631 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17632 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17633 return 1;
17634 }
17635
17636
17637 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17638 PyObject *pyobj = 0;
17639
17640 {
17641 #if wxUSE_UNICODE
17642 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17643 #else
17644 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17645 #endif
17646 }
17647 return pyobj;
17648 }
17649
17650
17651 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17652 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17653 return 1;
17654 }
17655
17656
17657 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17658 PyObject *pyobj = 0;
17659
17660 {
17661 #if wxUSE_UNICODE
17662 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17663 #else
17664 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17665 #endif
17666 }
17667 return pyobj;
17668 }
17669
17670
17671 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17672 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17673 return 1;
17674 }
17675
17676
17677 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17678 PyObject *pyobj = 0;
17679
17680 {
17681 #if wxUSE_UNICODE
17682 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17683 #else
17684 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17685 #endif
17686 }
17687 return pyobj;
17688 }
17689
17690
17691 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17692 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17693 return 1;
17694 }
17695
17696
17697 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17698 PyObject *pyobj = 0;
17699
17700 {
17701 #if wxUSE_UNICODE
17702 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17703 #else
17704 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17705 #endif
17706 }
17707 return pyobj;
17708 }
17709
17710
17711 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17712 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17713 return 1;
17714 }
17715
17716
17717 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17718 PyObject *pyobj = 0;
17719
17720 {
17721 #if wxUSE_UNICODE
17722 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17723 #else
17724 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17725 #endif
17726 }
17727 return pyobj;
17728 }
17729
17730
17731 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17732 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17733 return 1;
17734 }
17735
17736
17737 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17738 PyObject *pyobj = 0;
17739
17740 {
17741 #if wxUSE_UNICODE
17742 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17743 #else
17744 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17745 #endif
17746 }
17747 return pyobj;
17748 }
17749
17750
17751 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17752 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17753 return 1;
17754 }
17755
17756
17757 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17758 PyObject *pyobj = 0;
17759
17760 {
17761 #if wxUSE_UNICODE
17762 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17763 #else
17764 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17765 #endif
17766 }
17767 return pyobj;
17768 }
17769
17770
17771 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17772 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17773 return 1;
17774 }
17775
17776
17777 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17778 PyObject *pyobj = 0;
17779
17780 {
17781 #if wxUSE_UNICODE
17782 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17783 #else
17784 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17785 #endif
17786 }
17787 return pyobj;
17788 }
17789
17790
17791 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17792 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17793 return 1;
17794 }
17795
17796
17797 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17798 PyObject *pyobj = 0;
17799
17800 {
17801 #if wxUSE_UNICODE
17802 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17803 #else
17804 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17805 #endif
17806 }
17807 return pyobj;
17808 }
17809
17810
17811 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17812 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17813 return 1;
17814 }
17815
17816
17817 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17818 PyObject *pyobj = 0;
17819
17820 {
17821 #if wxUSE_UNICODE
17822 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17823 #else
17824 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17825 #endif
17826 }
17827 return pyobj;
17828 }
17829
17830
17831 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17832 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17833 return 1;
17834 }
17835
17836
17837 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17838 PyObject *pyobj = 0;
17839
17840 {
17841 #if wxUSE_UNICODE
17842 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17843 #else
17844 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17845 #endif
17846 }
17847 return pyobj;
17848 }
17849
17850
17851 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17852 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17853 return 1;
17854 }
17855
17856
17857 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17858 PyObject *pyobj = 0;
17859
17860 {
17861 #if wxUSE_UNICODE
17862 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17863 #else
17864 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17865 #endif
17866 }
17867 return pyobj;
17868 }
17869
17870
17871 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17872 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17873 return 1;
17874 }
17875
17876
17877 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17878 PyObject *pyobj = 0;
17879
17880 {
17881 #if wxUSE_UNICODE
17882 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17883 #else
17884 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17885 #endif
17886 }
17887 return pyobj;
17888 }
17889
17890
17891 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17892 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17893 return 1;
17894 }
17895
17896
17897 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17898 PyObject *pyobj = 0;
17899
17900 {
17901 #if wxUSE_UNICODE
17902 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17903 #else
17904 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17905 #endif
17906 }
17907 return pyobj;
17908 }
17909
17910
17911 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17912 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17913 return 1;
17914 }
17915
17916
17917 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17918 PyObject *pyobj = 0;
17919
17920 {
17921 #if wxUSE_UNICODE
17922 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17923 #else
17924 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17925 #endif
17926 }
17927 return pyobj;
17928 }
17929
17930
17931 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17932 PyObject *resultobj = 0;
17933 wxBMPHandler *result = 0 ;
17934
17935 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17936 {
17937 PyThreadState* __tstate = wxPyBeginAllowThreads();
17938 result = (wxBMPHandler *)new wxBMPHandler();
17939 wxPyEndAllowThreads(__tstate);
17940 if (PyErr_Occurred()) SWIG_fail;
17941 }
17942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17943 return resultobj;
17944 fail:
17945 return NULL;
17946 }
17947
17948
17949 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17950 PyObject *obj;
17951 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17952 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17953 return SWIG_Py_Void();
17954 }
17955
17956 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17957 return SWIG_Python_InitShadowInstance(args);
17958 }
17959
17960 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17961 PyObject *resultobj = 0;
17962 wxICOHandler *result = 0 ;
17963
17964 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17965 {
17966 PyThreadState* __tstate = wxPyBeginAllowThreads();
17967 result = (wxICOHandler *)new wxICOHandler();
17968 wxPyEndAllowThreads(__tstate);
17969 if (PyErr_Occurred()) SWIG_fail;
17970 }
17971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17972 return resultobj;
17973 fail:
17974 return NULL;
17975 }
17976
17977
17978 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17979 PyObject *obj;
17980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17981 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17982 return SWIG_Py_Void();
17983 }
17984
17985 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17986 return SWIG_Python_InitShadowInstance(args);
17987 }
17988
17989 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17990 PyObject *resultobj = 0;
17991 wxCURHandler *result = 0 ;
17992
17993 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17994 {
17995 PyThreadState* __tstate = wxPyBeginAllowThreads();
17996 result = (wxCURHandler *)new wxCURHandler();
17997 wxPyEndAllowThreads(__tstate);
17998 if (PyErr_Occurred()) SWIG_fail;
17999 }
18000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
18001 return resultobj;
18002 fail:
18003 return NULL;
18004 }
18005
18006
18007 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18008 PyObject *obj;
18009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18010 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
18011 return SWIG_Py_Void();
18012 }
18013
18014 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18015 return SWIG_Python_InitShadowInstance(args);
18016 }
18017
18018 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18019 PyObject *resultobj = 0;
18020 wxANIHandler *result = 0 ;
18021
18022 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
18023 {
18024 PyThreadState* __tstate = wxPyBeginAllowThreads();
18025 result = (wxANIHandler *)new wxANIHandler();
18026 wxPyEndAllowThreads(__tstate);
18027 if (PyErr_Occurred()) SWIG_fail;
18028 }
18029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
18030 return resultobj;
18031 fail:
18032 return NULL;
18033 }
18034
18035
18036 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18037 PyObject *obj;
18038 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18039 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
18040 return SWIG_Py_Void();
18041 }
18042
18043 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18044 return SWIG_Python_InitShadowInstance(args);
18045 }
18046
18047 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18048 PyObject *resultobj = 0;
18049 wxPNGHandler *result = 0 ;
18050
18051 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
18052 {
18053 PyThreadState* __tstate = wxPyBeginAllowThreads();
18054 result = (wxPNGHandler *)new wxPNGHandler();
18055 wxPyEndAllowThreads(__tstate);
18056 if (PyErr_Occurred()) SWIG_fail;
18057 }
18058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
18059 return resultobj;
18060 fail:
18061 return NULL;
18062 }
18063
18064
18065 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18066 PyObject *obj;
18067 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18068 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
18069 return SWIG_Py_Void();
18070 }
18071
18072 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18073 return SWIG_Python_InitShadowInstance(args);
18074 }
18075
18076 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18077 PyObject *resultobj = 0;
18078 wxGIFHandler *result = 0 ;
18079
18080 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
18081 {
18082 PyThreadState* __tstate = wxPyBeginAllowThreads();
18083 result = (wxGIFHandler *)new wxGIFHandler();
18084 wxPyEndAllowThreads(__tstate);
18085 if (PyErr_Occurred()) SWIG_fail;
18086 }
18087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
18088 return resultobj;
18089 fail:
18090 return NULL;
18091 }
18092
18093
18094 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18095 PyObject *obj;
18096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18097 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
18098 return SWIG_Py_Void();
18099 }
18100
18101 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18102 return SWIG_Python_InitShadowInstance(args);
18103 }
18104
18105 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18106 PyObject *resultobj = 0;
18107 wxPCXHandler *result = 0 ;
18108
18109 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
18110 {
18111 PyThreadState* __tstate = wxPyBeginAllowThreads();
18112 result = (wxPCXHandler *)new wxPCXHandler();
18113 wxPyEndAllowThreads(__tstate);
18114 if (PyErr_Occurred()) SWIG_fail;
18115 }
18116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
18117 return resultobj;
18118 fail:
18119 return NULL;
18120 }
18121
18122
18123 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18124 PyObject *obj;
18125 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18126 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
18127 return SWIG_Py_Void();
18128 }
18129
18130 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18131 return SWIG_Python_InitShadowInstance(args);
18132 }
18133
18134 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18135 PyObject *resultobj = 0;
18136 wxJPEGHandler *result = 0 ;
18137
18138 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
18139 {
18140 PyThreadState* __tstate = wxPyBeginAllowThreads();
18141 result = (wxJPEGHandler *)new wxJPEGHandler();
18142 wxPyEndAllowThreads(__tstate);
18143 if (PyErr_Occurred()) SWIG_fail;
18144 }
18145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
18146 return resultobj;
18147 fail:
18148 return NULL;
18149 }
18150
18151
18152 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18153 PyObject *obj;
18154 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18155 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
18156 return SWIG_Py_Void();
18157 }
18158
18159 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18160 return SWIG_Python_InitShadowInstance(args);
18161 }
18162
18163 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18164 PyObject *resultobj = 0;
18165 wxPNMHandler *result = 0 ;
18166
18167 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
18168 {
18169 PyThreadState* __tstate = wxPyBeginAllowThreads();
18170 result = (wxPNMHandler *)new wxPNMHandler();
18171 wxPyEndAllowThreads(__tstate);
18172 if (PyErr_Occurred()) SWIG_fail;
18173 }
18174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
18175 return resultobj;
18176 fail:
18177 return NULL;
18178 }
18179
18180
18181 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18182 PyObject *obj;
18183 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18184 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
18185 return SWIG_Py_Void();
18186 }
18187
18188 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18189 return SWIG_Python_InitShadowInstance(args);
18190 }
18191
18192 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18193 PyObject *resultobj = 0;
18194 wxXPMHandler *result = 0 ;
18195
18196 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
18197 {
18198 PyThreadState* __tstate = wxPyBeginAllowThreads();
18199 result = (wxXPMHandler *)new wxXPMHandler();
18200 wxPyEndAllowThreads(__tstate);
18201 if (PyErr_Occurred()) SWIG_fail;
18202 }
18203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
18204 return resultobj;
18205 fail:
18206 return NULL;
18207 }
18208
18209
18210 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18211 PyObject *obj;
18212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18213 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
18214 return SWIG_Py_Void();
18215 }
18216
18217 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18218 return SWIG_Python_InitShadowInstance(args);
18219 }
18220
18221 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18222 PyObject *resultobj = 0;
18223 wxTIFFHandler *result = 0 ;
18224
18225 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
18226 {
18227 PyThreadState* __tstate = wxPyBeginAllowThreads();
18228 result = (wxTIFFHandler *)new wxTIFFHandler();
18229 wxPyEndAllowThreads(__tstate);
18230 if (PyErr_Occurred()) SWIG_fail;
18231 }
18232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
18233 return resultobj;
18234 fail:
18235 return NULL;
18236 }
18237
18238
18239 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18240 PyObject *obj;
18241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18242 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
18243 return SWIG_Py_Void();
18244 }
18245
18246 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18247 return SWIG_Python_InitShadowInstance(args);
18248 }
18249
18250 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18251 PyObject *resultobj = 0;
18252 wxImage *arg1 = 0 ;
18253 wxImage *arg2 = 0 ;
18254 int arg3 = (int) 236 ;
18255 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
18256 bool result;
18257 void *argp1 = 0 ;
18258 int res1 = 0 ;
18259 void *argp2 = 0 ;
18260 int res2 = 0 ;
18261 int val3 ;
18262 int ecode3 = 0 ;
18263 int val4 ;
18264 int ecode4 = 0 ;
18265 PyObject * obj0 = 0 ;
18266 PyObject * obj1 = 0 ;
18267 PyObject * obj2 = 0 ;
18268 PyObject * obj3 = 0 ;
18269 char * kwnames[] = {
18270 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
18271 };
18272
18273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18274 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
18275 if (!SWIG_IsOK(res1)) {
18276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18277 }
18278 if (!argp1) {
18279 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18280 }
18281 arg1 = reinterpret_cast< wxImage * >(argp1);
18282 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
18283 if (!SWIG_IsOK(res2)) {
18284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18285 }
18286 if (!argp2) {
18287 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18288 }
18289 arg2 = reinterpret_cast< wxImage * >(argp2);
18290 if (obj2) {
18291 ecode3 = SWIG_AsVal_int(obj2, &val3);
18292 if (!SWIG_IsOK(ecode3)) {
18293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
18294 }
18295 arg3 = static_cast< int >(val3);
18296 }
18297 if (obj3) {
18298 ecode4 = SWIG_AsVal_int(obj3, &val4);
18299 if (!SWIG_IsOK(ecode4)) {
18300 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
18301 }
18302 arg4 = static_cast< int >(val4);
18303 }
18304 {
18305 PyThreadState* __tstate = wxPyBeginAllowThreads();
18306 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
18307 wxPyEndAllowThreads(__tstate);
18308 if (PyErr_Occurred()) SWIG_fail;
18309 }
18310 {
18311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18312 }
18313 return resultobj;
18314 fail:
18315 return NULL;
18316 }
18317
18318
18319 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18320 PyObject *obj;
18321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18322 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
18323 return SWIG_Py_Void();
18324 }
18325
18326 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18327 PyObject *resultobj = 0;
18328 wxEvtHandler *result = 0 ;
18329
18330 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
18331 {
18332 PyThreadState* __tstate = wxPyBeginAllowThreads();
18333 result = (wxEvtHandler *)new wxEvtHandler();
18334 wxPyEndAllowThreads(__tstate);
18335 if (PyErr_Occurred()) SWIG_fail;
18336 }
18337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
18338 return resultobj;
18339 fail:
18340 return NULL;
18341 }
18342
18343
18344 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18345 PyObject *resultobj = 0;
18346 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18347 wxEvtHandler *result = 0 ;
18348 void *argp1 = 0 ;
18349 int res1 = 0 ;
18350 PyObject *swig_obj[1] ;
18351
18352 if (!args) SWIG_fail;
18353 swig_obj[0] = args;
18354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18355 if (!SWIG_IsOK(res1)) {
18356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18357 }
18358 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18359 {
18360 PyThreadState* __tstate = wxPyBeginAllowThreads();
18361 result = (wxEvtHandler *)(arg1)->GetNextHandler();
18362 wxPyEndAllowThreads(__tstate);
18363 if (PyErr_Occurred()) SWIG_fail;
18364 }
18365 {
18366 resultobj = wxPyMake_wxObject(result, 0);
18367 }
18368 return resultobj;
18369 fail:
18370 return NULL;
18371 }
18372
18373
18374 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18375 PyObject *resultobj = 0;
18376 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18377 wxEvtHandler *result = 0 ;
18378 void *argp1 = 0 ;
18379 int res1 = 0 ;
18380 PyObject *swig_obj[1] ;
18381
18382 if (!args) SWIG_fail;
18383 swig_obj[0] = args;
18384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18385 if (!SWIG_IsOK(res1)) {
18386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18387 }
18388 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18389 {
18390 PyThreadState* __tstate = wxPyBeginAllowThreads();
18391 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
18392 wxPyEndAllowThreads(__tstate);
18393 if (PyErr_Occurred()) SWIG_fail;
18394 }
18395 {
18396 resultobj = wxPyMake_wxObject(result, 0);
18397 }
18398 return resultobj;
18399 fail:
18400 return NULL;
18401 }
18402
18403
18404 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18405 PyObject *resultobj = 0;
18406 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18407 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18408 void *argp1 = 0 ;
18409 int res1 = 0 ;
18410 void *argp2 = 0 ;
18411 int res2 = 0 ;
18412 PyObject * obj0 = 0 ;
18413 PyObject * obj1 = 0 ;
18414 char * kwnames[] = {
18415 (char *) "self",(char *) "handler", NULL
18416 };
18417
18418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18420 if (!SWIG_IsOK(res1)) {
18421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18422 }
18423 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18424 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18425 if (!SWIG_IsOK(res2)) {
18426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18427 }
18428 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18429 {
18430 PyThreadState* __tstate = wxPyBeginAllowThreads();
18431 (arg1)->SetNextHandler(arg2);
18432 wxPyEndAllowThreads(__tstate);
18433 if (PyErr_Occurred()) SWIG_fail;
18434 }
18435 resultobj = SWIG_Py_Void();
18436 return resultobj;
18437 fail:
18438 return NULL;
18439 }
18440
18441
18442 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18443 PyObject *resultobj = 0;
18444 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18445 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18446 void *argp1 = 0 ;
18447 int res1 = 0 ;
18448 void *argp2 = 0 ;
18449 int res2 = 0 ;
18450 PyObject * obj0 = 0 ;
18451 PyObject * obj1 = 0 ;
18452 char * kwnames[] = {
18453 (char *) "self",(char *) "handler", NULL
18454 };
18455
18456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18458 if (!SWIG_IsOK(res1)) {
18459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18460 }
18461 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18462 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18463 if (!SWIG_IsOK(res2)) {
18464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18465 }
18466 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18467 {
18468 PyThreadState* __tstate = wxPyBeginAllowThreads();
18469 (arg1)->SetPreviousHandler(arg2);
18470 wxPyEndAllowThreads(__tstate);
18471 if (PyErr_Occurred()) SWIG_fail;
18472 }
18473 resultobj = SWIG_Py_Void();
18474 return resultobj;
18475 fail:
18476 return NULL;
18477 }
18478
18479
18480 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18481 PyObject *resultobj = 0;
18482 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18483 bool result;
18484 void *argp1 = 0 ;
18485 int res1 = 0 ;
18486 PyObject *swig_obj[1] ;
18487
18488 if (!args) SWIG_fail;
18489 swig_obj[0] = args;
18490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18491 if (!SWIG_IsOK(res1)) {
18492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18493 }
18494 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18495 {
18496 PyThreadState* __tstate = wxPyBeginAllowThreads();
18497 result = (bool)(arg1)->GetEvtHandlerEnabled();
18498 wxPyEndAllowThreads(__tstate);
18499 if (PyErr_Occurred()) SWIG_fail;
18500 }
18501 {
18502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18503 }
18504 return resultobj;
18505 fail:
18506 return NULL;
18507 }
18508
18509
18510 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18511 PyObject *resultobj = 0;
18512 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18513 bool arg2 ;
18514 void *argp1 = 0 ;
18515 int res1 = 0 ;
18516 bool val2 ;
18517 int ecode2 = 0 ;
18518 PyObject * obj0 = 0 ;
18519 PyObject * obj1 = 0 ;
18520 char * kwnames[] = {
18521 (char *) "self",(char *) "enabled", NULL
18522 };
18523
18524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18526 if (!SWIG_IsOK(res1)) {
18527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18528 }
18529 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18530 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18531 if (!SWIG_IsOK(ecode2)) {
18532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18533 }
18534 arg2 = static_cast< bool >(val2);
18535 {
18536 PyThreadState* __tstate = wxPyBeginAllowThreads();
18537 (arg1)->SetEvtHandlerEnabled(arg2);
18538 wxPyEndAllowThreads(__tstate);
18539 if (PyErr_Occurred()) SWIG_fail;
18540 }
18541 resultobj = SWIG_Py_Void();
18542 return resultobj;
18543 fail:
18544 return NULL;
18545 }
18546
18547
18548 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18549 PyObject *resultobj = 0;
18550 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18551 wxEvent *arg2 = 0 ;
18552 bool result;
18553 void *argp1 = 0 ;
18554 int res1 = 0 ;
18555 void *argp2 = 0 ;
18556 int res2 = 0 ;
18557 PyObject * obj0 = 0 ;
18558 PyObject * obj1 = 0 ;
18559 char * kwnames[] = {
18560 (char *) "self",(char *) "event", NULL
18561 };
18562
18563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18565 if (!SWIG_IsOK(res1)) {
18566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18567 }
18568 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18569 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18570 if (!SWIG_IsOK(res2)) {
18571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18572 }
18573 if (!argp2) {
18574 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18575 }
18576 arg2 = reinterpret_cast< wxEvent * >(argp2);
18577 {
18578 PyThreadState* __tstate = wxPyBeginAllowThreads();
18579 result = (bool)(arg1)->ProcessEvent(*arg2);
18580 wxPyEndAllowThreads(__tstate);
18581 if (PyErr_Occurred()) SWIG_fail;
18582 }
18583 {
18584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18585 }
18586 return resultobj;
18587 fail:
18588 return NULL;
18589 }
18590
18591
18592 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18593 PyObject *resultobj = 0;
18594 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18595 wxEvent *arg2 = 0 ;
18596 void *argp1 = 0 ;
18597 int res1 = 0 ;
18598 void *argp2 = 0 ;
18599 int res2 = 0 ;
18600 PyObject * obj0 = 0 ;
18601 PyObject * obj1 = 0 ;
18602 char * kwnames[] = {
18603 (char *) "self",(char *) "event", NULL
18604 };
18605
18606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18608 if (!SWIG_IsOK(res1)) {
18609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18610 }
18611 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18612 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18613 if (!SWIG_IsOK(res2)) {
18614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18615 }
18616 if (!argp2) {
18617 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18618 }
18619 arg2 = reinterpret_cast< wxEvent * >(argp2);
18620 {
18621 PyThreadState* __tstate = wxPyBeginAllowThreads();
18622 (arg1)->AddPendingEvent(*arg2);
18623 wxPyEndAllowThreads(__tstate);
18624 if (PyErr_Occurred()) SWIG_fail;
18625 }
18626 resultobj = SWIG_Py_Void();
18627 return resultobj;
18628 fail:
18629 return NULL;
18630 }
18631
18632
18633 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18634 PyObject *resultobj = 0;
18635 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18636 void *argp1 = 0 ;
18637 int res1 = 0 ;
18638 PyObject *swig_obj[1] ;
18639
18640 if (!args) SWIG_fail;
18641 swig_obj[0] = args;
18642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18643 if (!SWIG_IsOK(res1)) {
18644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18645 }
18646 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18647 {
18648 PyThreadState* __tstate = wxPyBeginAllowThreads();
18649 (arg1)->ProcessPendingEvents();
18650 wxPyEndAllowThreads(__tstate);
18651 if (PyErr_Occurred()) SWIG_fail;
18652 }
18653 resultobj = SWIG_Py_Void();
18654 return resultobj;
18655 fail:
18656 return NULL;
18657 }
18658
18659
18660 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18661 PyObject *resultobj = 0;
18662 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18663 int arg2 ;
18664 int arg3 ;
18665 int arg4 ;
18666 PyObject *arg5 = (PyObject *) 0 ;
18667 void *argp1 = 0 ;
18668 int res1 = 0 ;
18669 int val2 ;
18670 int ecode2 = 0 ;
18671 int val3 ;
18672 int ecode3 = 0 ;
18673 int val4 ;
18674 int ecode4 = 0 ;
18675 PyObject * obj0 = 0 ;
18676 PyObject * obj1 = 0 ;
18677 PyObject * obj2 = 0 ;
18678 PyObject * obj3 = 0 ;
18679 PyObject * obj4 = 0 ;
18680 char * kwnames[] = {
18681 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18682 };
18683
18684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18686 if (!SWIG_IsOK(res1)) {
18687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18688 }
18689 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18690 ecode2 = SWIG_AsVal_int(obj1, &val2);
18691 if (!SWIG_IsOK(ecode2)) {
18692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18693 }
18694 arg2 = static_cast< int >(val2);
18695 ecode3 = SWIG_AsVal_int(obj2, &val3);
18696 if (!SWIG_IsOK(ecode3)) {
18697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18698 }
18699 arg3 = static_cast< int >(val3);
18700 ecode4 = SWIG_AsVal_int(obj3, &val4);
18701 if (!SWIG_IsOK(ecode4)) {
18702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18703 }
18704 arg4 = static_cast< int >(val4);
18705 arg5 = obj4;
18706 {
18707 PyThreadState* __tstate = wxPyBeginAllowThreads();
18708 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18709 wxPyEndAllowThreads(__tstate);
18710 if (PyErr_Occurred()) SWIG_fail;
18711 }
18712 resultobj = SWIG_Py_Void();
18713 return resultobj;
18714 fail:
18715 return NULL;
18716 }
18717
18718
18719 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18720 PyObject *resultobj = 0;
18721 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18722 int arg2 ;
18723 int arg3 = (int) -1 ;
18724 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18725 bool result;
18726 void *argp1 = 0 ;
18727 int res1 = 0 ;
18728 int val2 ;
18729 int ecode2 = 0 ;
18730 int val3 ;
18731 int ecode3 = 0 ;
18732 int val4 ;
18733 int ecode4 = 0 ;
18734 PyObject * obj0 = 0 ;
18735 PyObject * obj1 = 0 ;
18736 PyObject * obj2 = 0 ;
18737 PyObject * obj3 = 0 ;
18738 char * kwnames[] = {
18739 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18740 };
18741
18742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18744 if (!SWIG_IsOK(res1)) {
18745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18746 }
18747 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18748 ecode2 = SWIG_AsVal_int(obj1, &val2);
18749 if (!SWIG_IsOK(ecode2)) {
18750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18751 }
18752 arg2 = static_cast< int >(val2);
18753 if (obj2) {
18754 ecode3 = SWIG_AsVal_int(obj2, &val3);
18755 if (!SWIG_IsOK(ecode3)) {
18756 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18757 }
18758 arg3 = static_cast< int >(val3);
18759 }
18760 if (obj3) {
18761 ecode4 = SWIG_AsVal_int(obj3, &val4);
18762 if (!SWIG_IsOK(ecode4)) {
18763 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18764 }
18765 arg4 = static_cast< wxEventType >(val4);
18766 }
18767 {
18768 PyThreadState* __tstate = wxPyBeginAllowThreads();
18769 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18770 wxPyEndAllowThreads(__tstate);
18771 if (PyErr_Occurred()) SWIG_fail;
18772 }
18773 {
18774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18775 }
18776 return resultobj;
18777 fail:
18778 return NULL;
18779 }
18780
18781
18782 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18783 PyObject *resultobj = 0;
18784 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18785 PyObject *arg2 = (PyObject *) 0 ;
18786 bool arg3 = (bool) true ;
18787 void *argp1 = 0 ;
18788 int res1 = 0 ;
18789 bool val3 ;
18790 int ecode3 = 0 ;
18791 PyObject * obj0 = 0 ;
18792 PyObject * obj1 = 0 ;
18793 PyObject * obj2 = 0 ;
18794 char * kwnames[] = {
18795 (char *) "self",(char *) "_self",(char *) "incref", NULL
18796 };
18797
18798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18800 if (!SWIG_IsOK(res1)) {
18801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18802 }
18803 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18804 arg2 = obj1;
18805 if (obj2) {
18806 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18807 if (!SWIG_IsOK(ecode3)) {
18808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18809 }
18810 arg3 = static_cast< bool >(val3);
18811 }
18812 {
18813 PyThreadState* __tstate = wxPyBeginAllowThreads();
18814 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18815 wxPyEndAllowThreads(__tstate);
18816 if (PyErr_Occurred()) SWIG_fail;
18817 }
18818 resultobj = SWIG_Py_Void();
18819 return resultobj;
18820 fail:
18821 return NULL;
18822 }
18823
18824
18825 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18826 PyObject *obj;
18827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18828 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18829 return SWIG_Py_Void();
18830 }
18831
18832 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18833 return SWIG_Python_InitShadowInstance(args);
18834 }
18835
18836 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18837 PyObject *resultobj = 0;
18838 wxEventType result;
18839
18840 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18841 {
18842 PyThreadState* __tstate = wxPyBeginAllowThreads();
18843 result = (wxEventType)wxNewEventType();
18844 wxPyEndAllowThreads(__tstate);
18845 if (PyErr_Occurred()) SWIG_fail;
18846 }
18847 resultobj = SWIG_From_int(static_cast< int >(result));
18848 return resultobj;
18849 fail:
18850 return NULL;
18851 }
18852
18853
18854 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18855 PyObject *resultobj = 0;
18856 wxEvent *arg1 = (wxEvent *) 0 ;
18857 void *argp1 = 0 ;
18858 int res1 = 0 ;
18859 PyObject *swig_obj[1] ;
18860
18861 if (!args) SWIG_fail;
18862 swig_obj[0] = args;
18863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18864 if (!SWIG_IsOK(res1)) {
18865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18866 }
18867 arg1 = reinterpret_cast< wxEvent * >(argp1);
18868 {
18869 PyThreadState* __tstate = wxPyBeginAllowThreads();
18870 delete arg1;
18871
18872 wxPyEndAllowThreads(__tstate);
18873 if (PyErr_Occurred()) SWIG_fail;
18874 }
18875 resultobj = SWIG_Py_Void();
18876 return resultobj;
18877 fail:
18878 return NULL;
18879 }
18880
18881
18882 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18883 PyObject *resultobj = 0;
18884 wxEvent *arg1 = (wxEvent *) 0 ;
18885 wxEventType arg2 ;
18886 void *argp1 = 0 ;
18887 int res1 = 0 ;
18888 int val2 ;
18889 int ecode2 = 0 ;
18890 PyObject * obj0 = 0 ;
18891 PyObject * obj1 = 0 ;
18892 char * kwnames[] = {
18893 (char *) "self",(char *) "typ", NULL
18894 };
18895
18896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18898 if (!SWIG_IsOK(res1)) {
18899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18900 }
18901 arg1 = reinterpret_cast< wxEvent * >(argp1);
18902 ecode2 = SWIG_AsVal_int(obj1, &val2);
18903 if (!SWIG_IsOK(ecode2)) {
18904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18905 }
18906 arg2 = static_cast< wxEventType >(val2);
18907 {
18908 PyThreadState* __tstate = wxPyBeginAllowThreads();
18909 (arg1)->SetEventType(arg2);
18910 wxPyEndAllowThreads(__tstate);
18911 if (PyErr_Occurred()) SWIG_fail;
18912 }
18913 resultobj = SWIG_Py_Void();
18914 return resultobj;
18915 fail:
18916 return NULL;
18917 }
18918
18919
18920 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18921 PyObject *resultobj = 0;
18922 wxEvent *arg1 = (wxEvent *) 0 ;
18923 wxEventType result;
18924 void *argp1 = 0 ;
18925 int res1 = 0 ;
18926 PyObject *swig_obj[1] ;
18927
18928 if (!args) SWIG_fail;
18929 swig_obj[0] = args;
18930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18931 if (!SWIG_IsOK(res1)) {
18932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18933 }
18934 arg1 = reinterpret_cast< wxEvent * >(argp1);
18935 {
18936 PyThreadState* __tstate = wxPyBeginAllowThreads();
18937 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18938 wxPyEndAllowThreads(__tstate);
18939 if (PyErr_Occurred()) SWIG_fail;
18940 }
18941 resultobj = SWIG_From_int(static_cast< int >(result));
18942 return resultobj;
18943 fail:
18944 return NULL;
18945 }
18946
18947
18948 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18949 PyObject *resultobj = 0;
18950 wxEvent *arg1 = (wxEvent *) 0 ;
18951 wxObject *result = 0 ;
18952 void *argp1 = 0 ;
18953 int res1 = 0 ;
18954 PyObject *swig_obj[1] ;
18955
18956 if (!args) SWIG_fail;
18957 swig_obj[0] = args;
18958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18959 if (!SWIG_IsOK(res1)) {
18960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18961 }
18962 arg1 = reinterpret_cast< wxEvent * >(argp1);
18963 {
18964 PyThreadState* __tstate = wxPyBeginAllowThreads();
18965 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18966 wxPyEndAllowThreads(__tstate);
18967 if (PyErr_Occurred()) SWIG_fail;
18968 }
18969 {
18970 resultobj = wxPyMake_wxObject(result, (bool)0);
18971 }
18972 return resultobj;
18973 fail:
18974 return NULL;
18975 }
18976
18977
18978 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18979 PyObject *resultobj = 0;
18980 wxEvent *arg1 = (wxEvent *) 0 ;
18981 wxObject *arg2 = (wxObject *) 0 ;
18982 void *argp1 = 0 ;
18983 int res1 = 0 ;
18984 void *argp2 = 0 ;
18985 int res2 = 0 ;
18986 PyObject * obj0 = 0 ;
18987 PyObject * obj1 = 0 ;
18988 char * kwnames[] = {
18989 (char *) "self",(char *) "obj", NULL
18990 };
18991
18992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18994 if (!SWIG_IsOK(res1)) {
18995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18996 }
18997 arg1 = reinterpret_cast< wxEvent * >(argp1);
18998 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18999 if (!SWIG_IsOK(res2)) {
19000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
19001 }
19002 arg2 = reinterpret_cast< wxObject * >(argp2);
19003 {
19004 PyThreadState* __tstate = wxPyBeginAllowThreads();
19005 (arg1)->SetEventObject(arg2);
19006 wxPyEndAllowThreads(__tstate);
19007 if (PyErr_Occurred()) SWIG_fail;
19008 }
19009 resultobj = SWIG_Py_Void();
19010 return resultobj;
19011 fail:
19012 return NULL;
19013 }
19014
19015
19016 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19017 PyObject *resultobj = 0;
19018 wxEvent *arg1 = (wxEvent *) 0 ;
19019 long result;
19020 void *argp1 = 0 ;
19021 int res1 = 0 ;
19022 PyObject *swig_obj[1] ;
19023
19024 if (!args) SWIG_fail;
19025 swig_obj[0] = args;
19026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19027 if (!SWIG_IsOK(res1)) {
19028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
19029 }
19030 arg1 = reinterpret_cast< wxEvent * >(argp1);
19031 {
19032 PyThreadState* __tstate = wxPyBeginAllowThreads();
19033 result = (long)((wxEvent const *)arg1)->GetTimestamp();
19034 wxPyEndAllowThreads(__tstate);
19035 if (PyErr_Occurred()) SWIG_fail;
19036 }
19037 resultobj = SWIG_From_long(static_cast< long >(result));
19038 return resultobj;
19039 fail:
19040 return NULL;
19041 }
19042
19043
19044 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19045 PyObject *resultobj = 0;
19046 wxEvent *arg1 = (wxEvent *) 0 ;
19047 long arg2 = (long) 0 ;
19048 void *argp1 = 0 ;
19049 int res1 = 0 ;
19050 long val2 ;
19051 int ecode2 = 0 ;
19052 PyObject * obj0 = 0 ;
19053 PyObject * obj1 = 0 ;
19054 char * kwnames[] = {
19055 (char *) "self",(char *) "ts", NULL
19056 };
19057
19058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
19059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19060 if (!SWIG_IsOK(res1)) {
19061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
19062 }
19063 arg1 = reinterpret_cast< wxEvent * >(argp1);
19064 if (obj1) {
19065 ecode2 = SWIG_AsVal_long(obj1, &val2);
19066 if (!SWIG_IsOK(ecode2)) {
19067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
19068 }
19069 arg2 = static_cast< long >(val2);
19070 }
19071 {
19072 PyThreadState* __tstate = wxPyBeginAllowThreads();
19073 (arg1)->SetTimestamp(arg2);
19074 wxPyEndAllowThreads(__tstate);
19075 if (PyErr_Occurred()) SWIG_fail;
19076 }
19077 resultobj = SWIG_Py_Void();
19078 return resultobj;
19079 fail:
19080 return NULL;
19081 }
19082
19083
19084 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19085 PyObject *resultobj = 0;
19086 wxEvent *arg1 = (wxEvent *) 0 ;
19087 int result;
19088 void *argp1 = 0 ;
19089 int res1 = 0 ;
19090 PyObject *swig_obj[1] ;
19091
19092 if (!args) SWIG_fail;
19093 swig_obj[0] = args;
19094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19095 if (!SWIG_IsOK(res1)) {
19096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
19097 }
19098 arg1 = reinterpret_cast< wxEvent * >(argp1);
19099 {
19100 PyThreadState* __tstate = wxPyBeginAllowThreads();
19101 result = (int)((wxEvent const *)arg1)->GetId();
19102 wxPyEndAllowThreads(__tstate);
19103 if (PyErr_Occurred()) SWIG_fail;
19104 }
19105 resultobj = SWIG_From_int(static_cast< int >(result));
19106 return resultobj;
19107 fail:
19108 return NULL;
19109 }
19110
19111
19112 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19113 PyObject *resultobj = 0;
19114 wxEvent *arg1 = (wxEvent *) 0 ;
19115 int arg2 ;
19116 void *argp1 = 0 ;
19117 int res1 = 0 ;
19118 int val2 ;
19119 int ecode2 = 0 ;
19120 PyObject * obj0 = 0 ;
19121 PyObject * obj1 = 0 ;
19122 char * kwnames[] = {
19123 (char *) "self",(char *) "Id", NULL
19124 };
19125
19126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
19127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19128 if (!SWIG_IsOK(res1)) {
19129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
19130 }
19131 arg1 = reinterpret_cast< wxEvent * >(argp1);
19132 ecode2 = SWIG_AsVal_int(obj1, &val2);
19133 if (!SWIG_IsOK(ecode2)) {
19134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
19135 }
19136 arg2 = static_cast< int >(val2);
19137 {
19138 PyThreadState* __tstate = wxPyBeginAllowThreads();
19139 (arg1)->SetId(arg2);
19140 wxPyEndAllowThreads(__tstate);
19141 if (PyErr_Occurred()) SWIG_fail;
19142 }
19143 resultobj = SWIG_Py_Void();
19144 return resultobj;
19145 fail:
19146 return NULL;
19147 }
19148
19149
19150 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19151 PyObject *resultobj = 0;
19152 wxEvent *arg1 = (wxEvent *) 0 ;
19153 bool result;
19154 void *argp1 = 0 ;
19155 int res1 = 0 ;
19156 PyObject *swig_obj[1] ;
19157
19158 if (!args) SWIG_fail;
19159 swig_obj[0] = args;
19160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19161 if (!SWIG_IsOK(res1)) {
19162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
19163 }
19164 arg1 = reinterpret_cast< wxEvent * >(argp1);
19165 {
19166 PyThreadState* __tstate = wxPyBeginAllowThreads();
19167 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
19168 wxPyEndAllowThreads(__tstate);
19169 if (PyErr_Occurred()) SWIG_fail;
19170 }
19171 {
19172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19173 }
19174 return resultobj;
19175 fail:
19176 return NULL;
19177 }
19178
19179
19180 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19181 PyObject *resultobj = 0;
19182 wxEvent *arg1 = (wxEvent *) 0 ;
19183 bool arg2 = (bool) true ;
19184 void *argp1 = 0 ;
19185 int res1 = 0 ;
19186 bool val2 ;
19187 int ecode2 = 0 ;
19188 PyObject * obj0 = 0 ;
19189 PyObject * obj1 = 0 ;
19190 char * kwnames[] = {
19191 (char *) "self",(char *) "skip", NULL
19192 };
19193
19194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
19195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19196 if (!SWIG_IsOK(res1)) {
19197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
19198 }
19199 arg1 = reinterpret_cast< wxEvent * >(argp1);
19200 if (obj1) {
19201 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19202 if (!SWIG_IsOK(ecode2)) {
19203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
19204 }
19205 arg2 = static_cast< bool >(val2);
19206 }
19207 {
19208 PyThreadState* __tstate = wxPyBeginAllowThreads();
19209 (arg1)->Skip(arg2);
19210 wxPyEndAllowThreads(__tstate);
19211 if (PyErr_Occurred()) SWIG_fail;
19212 }
19213 resultobj = SWIG_Py_Void();
19214 return resultobj;
19215 fail:
19216 return NULL;
19217 }
19218
19219
19220 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19221 PyObject *resultobj = 0;
19222 wxEvent *arg1 = (wxEvent *) 0 ;
19223 bool result;
19224 void *argp1 = 0 ;
19225 int res1 = 0 ;
19226 PyObject *swig_obj[1] ;
19227
19228 if (!args) SWIG_fail;
19229 swig_obj[0] = args;
19230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19231 if (!SWIG_IsOK(res1)) {
19232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
19233 }
19234 arg1 = reinterpret_cast< wxEvent * >(argp1);
19235 {
19236 PyThreadState* __tstate = wxPyBeginAllowThreads();
19237 result = (bool)((wxEvent const *)arg1)->GetSkipped();
19238 wxPyEndAllowThreads(__tstate);
19239 if (PyErr_Occurred()) SWIG_fail;
19240 }
19241 {
19242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19243 }
19244 return resultobj;
19245 fail:
19246 return NULL;
19247 }
19248
19249
19250 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19251 PyObject *resultobj = 0;
19252 wxEvent *arg1 = (wxEvent *) 0 ;
19253 bool result;
19254 void *argp1 = 0 ;
19255 int res1 = 0 ;
19256 PyObject *swig_obj[1] ;
19257
19258 if (!args) SWIG_fail;
19259 swig_obj[0] = args;
19260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19261 if (!SWIG_IsOK(res1)) {
19262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
19263 }
19264 arg1 = reinterpret_cast< wxEvent * >(argp1);
19265 {
19266 PyThreadState* __tstate = wxPyBeginAllowThreads();
19267 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
19268 wxPyEndAllowThreads(__tstate);
19269 if (PyErr_Occurred()) SWIG_fail;
19270 }
19271 {
19272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19273 }
19274 return resultobj;
19275 fail:
19276 return NULL;
19277 }
19278
19279
19280 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19281 PyObject *resultobj = 0;
19282 wxEvent *arg1 = (wxEvent *) 0 ;
19283 int result;
19284 void *argp1 = 0 ;
19285 int res1 = 0 ;
19286 PyObject *swig_obj[1] ;
19287
19288 if (!args) SWIG_fail;
19289 swig_obj[0] = args;
19290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19291 if (!SWIG_IsOK(res1)) {
19292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19293 }
19294 arg1 = reinterpret_cast< wxEvent * >(argp1);
19295 {
19296 PyThreadState* __tstate = wxPyBeginAllowThreads();
19297 result = (int)(arg1)->StopPropagation();
19298 wxPyEndAllowThreads(__tstate);
19299 if (PyErr_Occurred()) SWIG_fail;
19300 }
19301 resultobj = SWIG_From_int(static_cast< int >(result));
19302 return resultobj;
19303 fail:
19304 return NULL;
19305 }
19306
19307
19308 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19309 PyObject *resultobj = 0;
19310 wxEvent *arg1 = (wxEvent *) 0 ;
19311 int arg2 ;
19312 void *argp1 = 0 ;
19313 int res1 = 0 ;
19314 int val2 ;
19315 int ecode2 = 0 ;
19316 PyObject * obj0 = 0 ;
19317 PyObject * obj1 = 0 ;
19318 char * kwnames[] = {
19319 (char *) "self",(char *) "propagationLevel", NULL
19320 };
19321
19322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",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_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19326 }
19327 arg1 = reinterpret_cast< wxEvent * >(argp1);
19328 ecode2 = SWIG_AsVal_int(obj1, &val2);
19329 if (!SWIG_IsOK(ecode2)) {
19330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
19331 }
19332 arg2 = static_cast< int >(val2);
19333 {
19334 PyThreadState* __tstate = wxPyBeginAllowThreads();
19335 (arg1)->ResumePropagation(arg2);
19336 wxPyEndAllowThreads(__tstate);
19337 if (PyErr_Occurred()) SWIG_fail;
19338 }
19339 resultobj = SWIG_Py_Void();
19340 return resultobj;
19341 fail:
19342 return NULL;
19343 }
19344
19345
19346 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19347 PyObject *resultobj = 0;
19348 wxEvent *arg1 = (wxEvent *) 0 ;
19349 wxEvent *result = 0 ;
19350 void *argp1 = 0 ;
19351 int res1 = 0 ;
19352 PyObject *swig_obj[1] ;
19353
19354 if (!args) SWIG_fail;
19355 swig_obj[0] = args;
19356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19357 if (!SWIG_IsOK(res1)) {
19358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
19359 }
19360 arg1 = reinterpret_cast< wxEvent * >(argp1);
19361 {
19362 PyThreadState* __tstate = wxPyBeginAllowThreads();
19363 result = (wxEvent *)(arg1)->Clone();
19364 wxPyEndAllowThreads(__tstate);
19365 if (PyErr_Occurred()) SWIG_fail;
19366 }
19367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19368 return resultobj;
19369 fail:
19370 return NULL;
19371 }
19372
19373
19374 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19375 PyObject *obj;
19376 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19377 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
19378 return SWIG_Py_Void();
19379 }
19380
19381 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19382 PyObject *resultobj = 0;
19383 wxEvent *arg1 = 0 ;
19384 wxPropagationDisabler *result = 0 ;
19385 void *argp1 = 0 ;
19386 int res1 = 0 ;
19387 PyObject * obj0 = 0 ;
19388 char * kwnames[] = {
19389 (char *) "event", NULL
19390 };
19391
19392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
19393 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19394 if (!SWIG_IsOK(res1)) {
19395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19396 }
19397 if (!argp1) {
19398 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19399 }
19400 arg1 = reinterpret_cast< wxEvent * >(argp1);
19401 {
19402 PyThreadState* __tstate = wxPyBeginAllowThreads();
19403 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
19404 wxPyEndAllowThreads(__tstate);
19405 if (PyErr_Occurred()) SWIG_fail;
19406 }
19407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
19408 return resultobj;
19409 fail:
19410 return NULL;
19411 }
19412
19413
19414 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19415 PyObject *resultobj = 0;
19416 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
19417 void *argp1 = 0 ;
19418 int res1 = 0 ;
19419 PyObject *swig_obj[1] ;
19420
19421 if (!args) SWIG_fail;
19422 swig_obj[0] = args;
19423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
19424 if (!SWIG_IsOK(res1)) {
19425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
19426 }
19427 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
19428 {
19429 PyThreadState* __tstate = wxPyBeginAllowThreads();
19430 delete arg1;
19431
19432 wxPyEndAllowThreads(__tstate);
19433 if (PyErr_Occurred()) SWIG_fail;
19434 }
19435 resultobj = SWIG_Py_Void();
19436 return resultobj;
19437 fail:
19438 return NULL;
19439 }
19440
19441
19442 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19443 PyObject *obj;
19444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19445 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19446 return SWIG_Py_Void();
19447 }
19448
19449 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19450 return SWIG_Python_InitShadowInstance(args);
19451 }
19452
19453 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19454 PyObject *resultobj = 0;
19455 wxEvent *arg1 = 0 ;
19456 wxPropagateOnce *result = 0 ;
19457 void *argp1 = 0 ;
19458 int res1 = 0 ;
19459 PyObject * obj0 = 0 ;
19460 char * kwnames[] = {
19461 (char *) "event", NULL
19462 };
19463
19464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19465 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19466 if (!SWIG_IsOK(res1)) {
19467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19468 }
19469 if (!argp1) {
19470 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19471 }
19472 arg1 = reinterpret_cast< wxEvent * >(argp1);
19473 {
19474 PyThreadState* __tstate = wxPyBeginAllowThreads();
19475 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19476 wxPyEndAllowThreads(__tstate);
19477 if (PyErr_Occurred()) SWIG_fail;
19478 }
19479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19480 return resultobj;
19481 fail:
19482 return NULL;
19483 }
19484
19485
19486 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19487 PyObject *resultobj = 0;
19488 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19489 void *argp1 = 0 ;
19490 int res1 = 0 ;
19491 PyObject *swig_obj[1] ;
19492
19493 if (!args) SWIG_fail;
19494 swig_obj[0] = args;
19495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19496 if (!SWIG_IsOK(res1)) {
19497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19498 }
19499 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19500 {
19501 PyThreadState* __tstate = wxPyBeginAllowThreads();
19502 delete arg1;
19503
19504 wxPyEndAllowThreads(__tstate);
19505 if (PyErr_Occurred()) SWIG_fail;
19506 }
19507 resultobj = SWIG_Py_Void();
19508 return resultobj;
19509 fail:
19510 return NULL;
19511 }
19512
19513
19514 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19515 PyObject *obj;
19516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19517 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19518 return SWIG_Py_Void();
19519 }
19520
19521 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19522 return SWIG_Python_InitShadowInstance(args);
19523 }
19524
19525 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19526 PyObject *resultobj = 0;
19527 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19528 int arg2 = (int) 0 ;
19529 wxCommandEvent *result = 0 ;
19530 int val1 ;
19531 int ecode1 = 0 ;
19532 int val2 ;
19533 int ecode2 = 0 ;
19534 PyObject * obj0 = 0 ;
19535 PyObject * obj1 = 0 ;
19536 char * kwnames[] = {
19537 (char *) "commandType",(char *) "winid", NULL
19538 };
19539
19540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19541 if (obj0) {
19542 ecode1 = SWIG_AsVal_int(obj0, &val1);
19543 if (!SWIG_IsOK(ecode1)) {
19544 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19545 }
19546 arg1 = static_cast< wxEventType >(val1);
19547 }
19548 if (obj1) {
19549 ecode2 = SWIG_AsVal_int(obj1, &val2);
19550 if (!SWIG_IsOK(ecode2)) {
19551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19552 }
19553 arg2 = static_cast< int >(val2);
19554 }
19555 {
19556 PyThreadState* __tstate = wxPyBeginAllowThreads();
19557 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19558 wxPyEndAllowThreads(__tstate);
19559 if (PyErr_Occurred()) SWIG_fail;
19560 }
19561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19562 return resultobj;
19563 fail:
19564 return NULL;
19565 }
19566
19567
19568 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19569 PyObject *resultobj = 0;
19570 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19571 int result;
19572 void *argp1 = 0 ;
19573 int res1 = 0 ;
19574 PyObject *swig_obj[1] ;
19575
19576 if (!args) SWIG_fail;
19577 swig_obj[0] = args;
19578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19579 if (!SWIG_IsOK(res1)) {
19580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19581 }
19582 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19583 {
19584 PyThreadState* __tstate = wxPyBeginAllowThreads();
19585 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19586 wxPyEndAllowThreads(__tstate);
19587 if (PyErr_Occurred()) SWIG_fail;
19588 }
19589 resultobj = SWIG_From_int(static_cast< int >(result));
19590 return resultobj;
19591 fail:
19592 return NULL;
19593 }
19594
19595
19596 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19597 PyObject *resultobj = 0;
19598 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19599 wxString *arg2 = 0 ;
19600 void *argp1 = 0 ;
19601 int res1 = 0 ;
19602 bool temp2 = false ;
19603 PyObject * obj0 = 0 ;
19604 PyObject * obj1 = 0 ;
19605 char * kwnames[] = {
19606 (char *) "self",(char *) "s", NULL
19607 };
19608
19609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19611 if (!SWIG_IsOK(res1)) {
19612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19613 }
19614 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19615 {
19616 arg2 = wxString_in_helper(obj1);
19617 if (arg2 == NULL) SWIG_fail;
19618 temp2 = true;
19619 }
19620 {
19621 PyThreadState* __tstate = wxPyBeginAllowThreads();
19622 (arg1)->SetString((wxString const &)*arg2);
19623 wxPyEndAllowThreads(__tstate);
19624 if (PyErr_Occurred()) SWIG_fail;
19625 }
19626 resultobj = SWIG_Py_Void();
19627 {
19628 if (temp2)
19629 delete arg2;
19630 }
19631 return resultobj;
19632 fail:
19633 {
19634 if (temp2)
19635 delete arg2;
19636 }
19637 return NULL;
19638 }
19639
19640
19641 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19642 PyObject *resultobj = 0;
19643 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19644 wxString result;
19645 void *argp1 = 0 ;
19646 int res1 = 0 ;
19647 PyObject *swig_obj[1] ;
19648
19649 if (!args) SWIG_fail;
19650 swig_obj[0] = args;
19651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19652 if (!SWIG_IsOK(res1)) {
19653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19654 }
19655 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19656 {
19657 PyThreadState* __tstate = wxPyBeginAllowThreads();
19658 result = ((wxCommandEvent const *)arg1)->GetString();
19659 wxPyEndAllowThreads(__tstate);
19660 if (PyErr_Occurred()) SWIG_fail;
19661 }
19662 {
19663 #if wxUSE_UNICODE
19664 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19665 #else
19666 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19667 #endif
19668 }
19669 return resultobj;
19670 fail:
19671 return NULL;
19672 }
19673
19674
19675 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19676 PyObject *resultobj = 0;
19677 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19678 bool result;
19679 void *argp1 = 0 ;
19680 int res1 = 0 ;
19681 PyObject *swig_obj[1] ;
19682
19683 if (!args) SWIG_fail;
19684 swig_obj[0] = args;
19685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19686 if (!SWIG_IsOK(res1)) {
19687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19688 }
19689 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19690 {
19691 PyThreadState* __tstate = wxPyBeginAllowThreads();
19692 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19693 wxPyEndAllowThreads(__tstate);
19694 if (PyErr_Occurred()) SWIG_fail;
19695 }
19696 {
19697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19698 }
19699 return resultobj;
19700 fail:
19701 return NULL;
19702 }
19703
19704
19705 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19706 PyObject *resultobj = 0;
19707 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19708 bool result;
19709 void *argp1 = 0 ;
19710 int res1 = 0 ;
19711 PyObject *swig_obj[1] ;
19712
19713 if (!args) SWIG_fail;
19714 swig_obj[0] = args;
19715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19716 if (!SWIG_IsOK(res1)) {
19717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19718 }
19719 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19720 {
19721 PyThreadState* __tstate = wxPyBeginAllowThreads();
19722 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19723 wxPyEndAllowThreads(__tstate);
19724 if (PyErr_Occurred()) SWIG_fail;
19725 }
19726 {
19727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19728 }
19729 return resultobj;
19730 fail:
19731 return NULL;
19732 }
19733
19734
19735 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19736 PyObject *resultobj = 0;
19737 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19738 long arg2 ;
19739 void *argp1 = 0 ;
19740 int res1 = 0 ;
19741 long val2 ;
19742 int ecode2 = 0 ;
19743 PyObject * obj0 = 0 ;
19744 PyObject * obj1 = 0 ;
19745 char * kwnames[] = {
19746 (char *) "self",(char *) "extraLong", NULL
19747 };
19748
19749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19751 if (!SWIG_IsOK(res1)) {
19752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19753 }
19754 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19755 ecode2 = SWIG_AsVal_long(obj1, &val2);
19756 if (!SWIG_IsOK(ecode2)) {
19757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19758 }
19759 arg2 = static_cast< long >(val2);
19760 {
19761 PyThreadState* __tstate = wxPyBeginAllowThreads();
19762 (arg1)->SetExtraLong(arg2);
19763 wxPyEndAllowThreads(__tstate);
19764 if (PyErr_Occurred()) SWIG_fail;
19765 }
19766 resultobj = SWIG_Py_Void();
19767 return resultobj;
19768 fail:
19769 return NULL;
19770 }
19771
19772
19773 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19774 PyObject *resultobj = 0;
19775 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19776 long result;
19777 void *argp1 = 0 ;
19778 int res1 = 0 ;
19779 PyObject *swig_obj[1] ;
19780
19781 if (!args) SWIG_fail;
19782 swig_obj[0] = args;
19783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19784 if (!SWIG_IsOK(res1)) {
19785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19786 }
19787 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19788 {
19789 PyThreadState* __tstate = wxPyBeginAllowThreads();
19790 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19791 wxPyEndAllowThreads(__tstate);
19792 if (PyErr_Occurred()) SWIG_fail;
19793 }
19794 resultobj = SWIG_From_long(static_cast< long >(result));
19795 return resultobj;
19796 fail:
19797 return NULL;
19798 }
19799
19800
19801 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19802 PyObject *resultobj = 0;
19803 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19804 int arg2 ;
19805 void *argp1 = 0 ;
19806 int res1 = 0 ;
19807 int val2 ;
19808 int ecode2 = 0 ;
19809 PyObject * obj0 = 0 ;
19810 PyObject * obj1 = 0 ;
19811 char * kwnames[] = {
19812 (char *) "self",(char *) "i", NULL
19813 };
19814
19815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19817 if (!SWIG_IsOK(res1)) {
19818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19819 }
19820 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19821 ecode2 = SWIG_AsVal_int(obj1, &val2);
19822 if (!SWIG_IsOK(ecode2)) {
19823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19824 }
19825 arg2 = static_cast< int >(val2);
19826 {
19827 PyThreadState* __tstate = wxPyBeginAllowThreads();
19828 (arg1)->SetInt(arg2);
19829 wxPyEndAllowThreads(__tstate);
19830 if (PyErr_Occurred()) SWIG_fail;
19831 }
19832 resultobj = SWIG_Py_Void();
19833 return resultobj;
19834 fail:
19835 return NULL;
19836 }
19837
19838
19839 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19840 PyObject *resultobj = 0;
19841 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19842 int result;
19843 void *argp1 = 0 ;
19844 int res1 = 0 ;
19845 PyObject *swig_obj[1] ;
19846
19847 if (!args) SWIG_fail;
19848 swig_obj[0] = args;
19849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19850 if (!SWIG_IsOK(res1)) {
19851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19852 }
19853 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19854 {
19855 PyThreadState* __tstate = wxPyBeginAllowThreads();
19856 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19857 wxPyEndAllowThreads(__tstate);
19858 if (PyErr_Occurred()) SWIG_fail;
19859 }
19860 resultobj = SWIG_From_int(static_cast< int >(result));
19861 return resultobj;
19862 fail:
19863 return NULL;
19864 }
19865
19866
19867 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19868 PyObject *resultobj = 0;
19869 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19870 PyObject *result = 0 ;
19871 void *argp1 = 0 ;
19872 int res1 = 0 ;
19873 PyObject *swig_obj[1] ;
19874
19875 if (!args) SWIG_fail;
19876 swig_obj[0] = args;
19877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19878 if (!SWIG_IsOK(res1)) {
19879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19880 }
19881 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19882 {
19883 PyThreadState* __tstate = wxPyBeginAllowThreads();
19884 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19885 wxPyEndAllowThreads(__tstate);
19886 if (PyErr_Occurred()) SWIG_fail;
19887 }
19888 resultobj = result;
19889 return resultobj;
19890 fail:
19891 return NULL;
19892 }
19893
19894
19895 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19896 PyObject *resultobj = 0;
19897 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19898 PyObject *arg2 = (PyObject *) 0 ;
19899 void *argp1 = 0 ;
19900 int res1 = 0 ;
19901 PyObject * obj0 = 0 ;
19902 PyObject * obj1 = 0 ;
19903 char * kwnames[] = {
19904 (char *) "self",(char *) "clientData", NULL
19905 };
19906
19907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19909 if (!SWIG_IsOK(res1)) {
19910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19911 }
19912 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19913 arg2 = obj1;
19914 {
19915 PyThreadState* __tstate = wxPyBeginAllowThreads();
19916 wxCommandEvent_SetClientData(arg1,arg2);
19917 wxPyEndAllowThreads(__tstate);
19918 if (PyErr_Occurred()) SWIG_fail;
19919 }
19920 resultobj = SWIG_Py_Void();
19921 return resultobj;
19922 fail:
19923 return NULL;
19924 }
19925
19926
19927 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19928 PyObject *resultobj = 0;
19929 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19930 wxEvent *result = 0 ;
19931 void *argp1 = 0 ;
19932 int res1 = 0 ;
19933 PyObject *swig_obj[1] ;
19934
19935 if (!args) SWIG_fail;
19936 swig_obj[0] = args;
19937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19938 if (!SWIG_IsOK(res1)) {
19939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19940 }
19941 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19942 {
19943 PyThreadState* __tstate = wxPyBeginAllowThreads();
19944 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19945 wxPyEndAllowThreads(__tstate);
19946 if (PyErr_Occurred()) SWIG_fail;
19947 }
19948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19949 return resultobj;
19950 fail:
19951 return NULL;
19952 }
19953
19954
19955 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19956 PyObject *obj;
19957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19958 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19959 return SWIG_Py_Void();
19960 }
19961
19962 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19963 return SWIG_Python_InitShadowInstance(args);
19964 }
19965
19966 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19967 PyObject *resultobj = 0;
19968 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19969 int arg2 = (int) 0 ;
19970 wxNotifyEvent *result = 0 ;
19971 int val1 ;
19972 int ecode1 = 0 ;
19973 int val2 ;
19974 int ecode2 = 0 ;
19975 PyObject * obj0 = 0 ;
19976 PyObject * obj1 = 0 ;
19977 char * kwnames[] = {
19978 (char *) "commandType",(char *) "winid", NULL
19979 };
19980
19981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19982 if (obj0) {
19983 ecode1 = SWIG_AsVal_int(obj0, &val1);
19984 if (!SWIG_IsOK(ecode1)) {
19985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19986 }
19987 arg1 = static_cast< wxEventType >(val1);
19988 }
19989 if (obj1) {
19990 ecode2 = SWIG_AsVal_int(obj1, &val2);
19991 if (!SWIG_IsOK(ecode2)) {
19992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19993 }
19994 arg2 = static_cast< int >(val2);
19995 }
19996 {
19997 PyThreadState* __tstate = wxPyBeginAllowThreads();
19998 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19999 wxPyEndAllowThreads(__tstate);
20000 if (PyErr_Occurred()) SWIG_fail;
20001 }
20002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
20003 return resultobj;
20004 fail:
20005 return NULL;
20006 }
20007
20008
20009 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20010 PyObject *resultobj = 0;
20011 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20012 void *argp1 = 0 ;
20013 int res1 = 0 ;
20014 PyObject *swig_obj[1] ;
20015
20016 if (!args) SWIG_fail;
20017 swig_obj[0] = args;
20018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20019 if (!SWIG_IsOK(res1)) {
20020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20021 }
20022 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20023 {
20024 PyThreadState* __tstate = wxPyBeginAllowThreads();
20025 (arg1)->Veto();
20026 wxPyEndAllowThreads(__tstate);
20027 if (PyErr_Occurred()) SWIG_fail;
20028 }
20029 resultobj = SWIG_Py_Void();
20030 return resultobj;
20031 fail:
20032 return NULL;
20033 }
20034
20035
20036 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20037 PyObject *resultobj = 0;
20038 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20039 void *argp1 = 0 ;
20040 int res1 = 0 ;
20041 PyObject *swig_obj[1] ;
20042
20043 if (!args) SWIG_fail;
20044 swig_obj[0] = args;
20045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20046 if (!SWIG_IsOK(res1)) {
20047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20048 }
20049 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20050 {
20051 PyThreadState* __tstate = wxPyBeginAllowThreads();
20052 (arg1)->Allow();
20053 wxPyEndAllowThreads(__tstate);
20054 if (PyErr_Occurred()) SWIG_fail;
20055 }
20056 resultobj = SWIG_Py_Void();
20057 return resultobj;
20058 fail:
20059 return NULL;
20060 }
20061
20062
20063 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20064 PyObject *resultobj = 0;
20065 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20066 bool result;
20067 void *argp1 = 0 ;
20068 int res1 = 0 ;
20069 PyObject *swig_obj[1] ;
20070
20071 if (!args) SWIG_fail;
20072 swig_obj[0] = args;
20073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20074 if (!SWIG_IsOK(res1)) {
20075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20076 }
20077 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20078 {
20079 PyThreadState* __tstate = wxPyBeginAllowThreads();
20080 result = (bool)(arg1)->IsAllowed();
20081 wxPyEndAllowThreads(__tstate);
20082 if (PyErr_Occurred()) SWIG_fail;
20083 }
20084 {
20085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20086 }
20087 return resultobj;
20088 fail:
20089 return NULL;
20090 }
20091
20092
20093 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20094 PyObject *obj;
20095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20096 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
20097 return SWIG_Py_Void();
20098 }
20099
20100 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20101 return SWIG_Python_InitShadowInstance(args);
20102 }
20103
20104 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20105 PyObject *resultobj = 0;
20106 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20107 int arg2 = (int) 0 ;
20108 int arg3 = (int) 0 ;
20109 int arg4 = (int) 0 ;
20110 wxScrollEvent *result = 0 ;
20111 int val1 ;
20112 int ecode1 = 0 ;
20113 int val2 ;
20114 int ecode2 = 0 ;
20115 int val3 ;
20116 int ecode3 = 0 ;
20117 int val4 ;
20118 int ecode4 = 0 ;
20119 PyObject * obj0 = 0 ;
20120 PyObject * obj1 = 0 ;
20121 PyObject * obj2 = 0 ;
20122 PyObject * obj3 = 0 ;
20123 char * kwnames[] = {
20124 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
20125 };
20126
20127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20128 if (obj0) {
20129 ecode1 = SWIG_AsVal_int(obj0, &val1);
20130 if (!SWIG_IsOK(ecode1)) {
20131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20132 }
20133 arg1 = static_cast< wxEventType >(val1);
20134 }
20135 if (obj1) {
20136 ecode2 = SWIG_AsVal_int(obj1, &val2);
20137 if (!SWIG_IsOK(ecode2)) {
20138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
20139 }
20140 arg2 = static_cast< int >(val2);
20141 }
20142 if (obj2) {
20143 ecode3 = SWIG_AsVal_int(obj2, &val3);
20144 if (!SWIG_IsOK(ecode3)) {
20145 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
20146 }
20147 arg3 = static_cast< int >(val3);
20148 }
20149 if (obj3) {
20150 ecode4 = SWIG_AsVal_int(obj3, &val4);
20151 if (!SWIG_IsOK(ecode4)) {
20152 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
20153 }
20154 arg4 = static_cast< int >(val4);
20155 }
20156 {
20157 PyThreadState* __tstate = wxPyBeginAllowThreads();
20158 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
20159 wxPyEndAllowThreads(__tstate);
20160 if (PyErr_Occurred()) SWIG_fail;
20161 }
20162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
20163 return resultobj;
20164 fail:
20165 return NULL;
20166 }
20167
20168
20169 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20170 PyObject *resultobj = 0;
20171 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20172 int result;
20173 void *argp1 = 0 ;
20174 int res1 = 0 ;
20175 PyObject *swig_obj[1] ;
20176
20177 if (!args) SWIG_fail;
20178 swig_obj[0] = args;
20179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20180 if (!SWIG_IsOK(res1)) {
20181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20182 }
20183 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20184 {
20185 PyThreadState* __tstate = wxPyBeginAllowThreads();
20186 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
20187 wxPyEndAllowThreads(__tstate);
20188 if (PyErr_Occurred()) SWIG_fail;
20189 }
20190 resultobj = SWIG_From_int(static_cast< int >(result));
20191 return resultobj;
20192 fail:
20193 return NULL;
20194 }
20195
20196
20197 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20198 PyObject *resultobj = 0;
20199 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20200 int result;
20201 void *argp1 = 0 ;
20202 int res1 = 0 ;
20203 PyObject *swig_obj[1] ;
20204
20205 if (!args) SWIG_fail;
20206 swig_obj[0] = args;
20207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20208 if (!SWIG_IsOK(res1)) {
20209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20210 }
20211 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20212 {
20213 PyThreadState* __tstate = wxPyBeginAllowThreads();
20214 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
20215 wxPyEndAllowThreads(__tstate);
20216 if (PyErr_Occurred()) SWIG_fail;
20217 }
20218 resultobj = SWIG_From_int(static_cast< int >(result));
20219 return resultobj;
20220 fail:
20221 return NULL;
20222 }
20223
20224
20225 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20226 PyObject *resultobj = 0;
20227 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20228 int arg2 ;
20229 void *argp1 = 0 ;
20230 int res1 = 0 ;
20231 int val2 ;
20232 int ecode2 = 0 ;
20233 PyObject * obj0 = 0 ;
20234 PyObject * obj1 = 0 ;
20235 char * kwnames[] = {
20236 (char *) "self",(char *) "orient", NULL
20237 };
20238
20239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20241 if (!SWIG_IsOK(res1)) {
20242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20243 }
20244 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20245 ecode2 = SWIG_AsVal_int(obj1, &val2);
20246 if (!SWIG_IsOK(ecode2)) {
20247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20248 }
20249 arg2 = static_cast< int >(val2);
20250 {
20251 PyThreadState* __tstate = wxPyBeginAllowThreads();
20252 (arg1)->SetOrientation(arg2);
20253 wxPyEndAllowThreads(__tstate);
20254 if (PyErr_Occurred()) SWIG_fail;
20255 }
20256 resultobj = SWIG_Py_Void();
20257 return resultobj;
20258 fail:
20259 return NULL;
20260 }
20261
20262
20263 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20264 PyObject *resultobj = 0;
20265 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20266 int arg2 ;
20267 void *argp1 = 0 ;
20268 int res1 = 0 ;
20269 int val2 ;
20270 int ecode2 = 0 ;
20271 PyObject * obj0 = 0 ;
20272 PyObject * obj1 = 0 ;
20273 char * kwnames[] = {
20274 (char *) "self",(char *) "pos", NULL
20275 };
20276
20277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20279 if (!SWIG_IsOK(res1)) {
20280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20281 }
20282 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20283 ecode2 = SWIG_AsVal_int(obj1, &val2);
20284 if (!SWIG_IsOK(ecode2)) {
20285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20286 }
20287 arg2 = static_cast< int >(val2);
20288 {
20289 PyThreadState* __tstate = wxPyBeginAllowThreads();
20290 (arg1)->SetPosition(arg2);
20291 wxPyEndAllowThreads(__tstate);
20292 if (PyErr_Occurred()) SWIG_fail;
20293 }
20294 resultobj = SWIG_Py_Void();
20295 return resultobj;
20296 fail:
20297 return NULL;
20298 }
20299
20300
20301 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20302 PyObject *obj;
20303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20304 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
20305 return SWIG_Py_Void();
20306 }
20307
20308 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20309 return SWIG_Python_InitShadowInstance(args);
20310 }
20311
20312 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20313 PyObject *resultobj = 0;
20314 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20315 int arg2 = (int) 0 ;
20316 int arg3 = (int) 0 ;
20317 wxScrollWinEvent *result = 0 ;
20318 int val1 ;
20319 int ecode1 = 0 ;
20320 int val2 ;
20321 int ecode2 = 0 ;
20322 int val3 ;
20323 int ecode3 = 0 ;
20324 PyObject * obj0 = 0 ;
20325 PyObject * obj1 = 0 ;
20326 PyObject * obj2 = 0 ;
20327 char * kwnames[] = {
20328 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
20329 };
20330
20331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20332 if (obj0) {
20333 ecode1 = SWIG_AsVal_int(obj0, &val1);
20334 if (!SWIG_IsOK(ecode1)) {
20335 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20336 }
20337 arg1 = static_cast< wxEventType >(val1);
20338 }
20339 if (obj1) {
20340 ecode2 = SWIG_AsVal_int(obj1, &val2);
20341 if (!SWIG_IsOK(ecode2)) {
20342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
20343 }
20344 arg2 = static_cast< int >(val2);
20345 }
20346 if (obj2) {
20347 ecode3 = SWIG_AsVal_int(obj2, &val3);
20348 if (!SWIG_IsOK(ecode3)) {
20349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
20350 }
20351 arg3 = static_cast< int >(val3);
20352 }
20353 {
20354 PyThreadState* __tstate = wxPyBeginAllowThreads();
20355 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
20356 wxPyEndAllowThreads(__tstate);
20357 if (PyErr_Occurred()) SWIG_fail;
20358 }
20359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
20360 return resultobj;
20361 fail:
20362 return NULL;
20363 }
20364
20365
20366 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20367 PyObject *resultobj = 0;
20368 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20369 int result;
20370 void *argp1 = 0 ;
20371 int res1 = 0 ;
20372 PyObject *swig_obj[1] ;
20373
20374 if (!args) SWIG_fail;
20375 swig_obj[0] = args;
20376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20377 if (!SWIG_IsOK(res1)) {
20378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20379 }
20380 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20381 {
20382 PyThreadState* __tstate = wxPyBeginAllowThreads();
20383 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
20384 wxPyEndAllowThreads(__tstate);
20385 if (PyErr_Occurred()) SWIG_fail;
20386 }
20387 resultobj = SWIG_From_int(static_cast< int >(result));
20388 return resultobj;
20389 fail:
20390 return NULL;
20391 }
20392
20393
20394 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20395 PyObject *resultobj = 0;
20396 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20397 int result;
20398 void *argp1 = 0 ;
20399 int res1 = 0 ;
20400 PyObject *swig_obj[1] ;
20401
20402 if (!args) SWIG_fail;
20403 swig_obj[0] = args;
20404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20405 if (!SWIG_IsOK(res1)) {
20406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20407 }
20408 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20409 {
20410 PyThreadState* __tstate = wxPyBeginAllowThreads();
20411 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
20412 wxPyEndAllowThreads(__tstate);
20413 if (PyErr_Occurred()) SWIG_fail;
20414 }
20415 resultobj = SWIG_From_int(static_cast< int >(result));
20416 return resultobj;
20417 fail:
20418 return NULL;
20419 }
20420
20421
20422 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20423 PyObject *resultobj = 0;
20424 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20425 int arg2 ;
20426 void *argp1 = 0 ;
20427 int res1 = 0 ;
20428 int val2 ;
20429 int ecode2 = 0 ;
20430 PyObject * obj0 = 0 ;
20431 PyObject * obj1 = 0 ;
20432 char * kwnames[] = {
20433 (char *) "self",(char *) "orient", NULL
20434 };
20435
20436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20438 if (!SWIG_IsOK(res1)) {
20439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20440 }
20441 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20442 ecode2 = SWIG_AsVal_int(obj1, &val2);
20443 if (!SWIG_IsOK(ecode2)) {
20444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20445 }
20446 arg2 = static_cast< int >(val2);
20447 {
20448 PyThreadState* __tstate = wxPyBeginAllowThreads();
20449 (arg1)->SetOrientation(arg2);
20450 wxPyEndAllowThreads(__tstate);
20451 if (PyErr_Occurred()) SWIG_fail;
20452 }
20453 resultobj = SWIG_Py_Void();
20454 return resultobj;
20455 fail:
20456 return NULL;
20457 }
20458
20459
20460 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20461 PyObject *resultobj = 0;
20462 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20463 int arg2 ;
20464 void *argp1 = 0 ;
20465 int res1 = 0 ;
20466 int val2 ;
20467 int ecode2 = 0 ;
20468 PyObject * obj0 = 0 ;
20469 PyObject * obj1 = 0 ;
20470 char * kwnames[] = {
20471 (char *) "self",(char *) "pos", NULL
20472 };
20473
20474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20476 if (!SWIG_IsOK(res1)) {
20477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20478 }
20479 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20480 ecode2 = SWIG_AsVal_int(obj1, &val2);
20481 if (!SWIG_IsOK(ecode2)) {
20482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20483 }
20484 arg2 = static_cast< int >(val2);
20485 {
20486 PyThreadState* __tstate = wxPyBeginAllowThreads();
20487 (arg1)->SetPosition(arg2);
20488 wxPyEndAllowThreads(__tstate);
20489 if (PyErr_Occurred()) SWIG_fail;
20490 }
20491 resultobj = SWIG_Py_Void();
20492 return resultobj;
20493 fail:
20494 return NULL;
20495 }
20496
20497
20498 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20499 PyObject *obj;
20500 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20501 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20502 return SWIG_Py_Void();
20503 }
20504
20505 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20506 return SWIG_Python_InitShadowInstance(args);
20507 }
20508
20509 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20510 PyObject *resultobj = 0;
20511 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20512 wxMouseEvent *result = 0 ;
20513 int val1 ;
20514 int ecode1 = 0 ;
20515 PyObject * obj0 = 0 ;
20516 char * kwnames[] = {
20517 (char *) "mouseType", NULL
20518 };
20519
20520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20521 if (obj0) {
20522 ecode1 = SWIG_AsVal_int(obj0, &val1);
20523 if (!SWIG_IsOK(ecode1)) {
20524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20525 }
20526 arg1 = static_cast< wxEventType >(val1);
20527 }
20528 {
20529 PyThreadState* __tstate = wxPyBeginAllowThreads();
20530 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20531 wxPyEndAllowThreads(__tstate);
20532 if (PyErr_Occurred()) SWIG_fail;
20533 }
20534 {
20535 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20536 }
20537 return resultobj;
20538 fail:
20539 return NULL;
20540 }
20541
20542
20543 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20544 PyObject *resultobj = 0;
20545 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20546 bool result;
20547 void *argp1 = 0 ;
20548 int res1 = 0 ;
20549 PyObject *swig_obj[1] ;
20550
20551 if (!args) SWIG_fail;
20552 swig_obj[0] = args;
20553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20554 if (!SWIG_IsOK(res1)) {
20555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20556 }
20557 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20558 {
20559 PyThreadState* __tstate = wxPyBeginAllowThreads();
20560 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20561 wxPyEndAllowThreads(__tstate);
20562 if (PyErr_Occurred()) SWIG_fail;
20563 }
20564 {
20565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20566 }
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20574 PyObject *resultobj = 0;
20575 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20576 int arg2 = (int) wxMOUSE_BTN_ANY ;
20577 bool result;
20578 void *argp1 = 0 ;
20579 int res1 = 0 ;
20580 int val2 ;
20581 int ecode2 = 0 ;
20582 PyObject * obj0 = 0 ;
20583 PyObject * obj1 = 0 ;
20584 char * kwnames[] = {
20585 (char *) "self",(char *) "but", NULL
20586 };
20587
20588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20590 if (!SWIG_IsOK(res1)) {
20591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20592 }
20593 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20594 if (obj1) {
20595 ecode2 = SWIG_AsVal_int(obj1, &val2);
20596 if (!SWIG_IsOK(ecode2)) {
20597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20598 }
20599 arg2 = static_cast< int >(val2);
20600 }
20601 {
20602 PyThreadState* __tstate = wxPyBeginAllowThreads();
20603 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20604 wxPyEndAllowThreads(__tstate);
20605 if (PyErr_Occurred()) SWIG_fail;
20606 }
20607 {
20608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20609 }
20610 return resultobj;
20611 fail:
20612 return NULL;
20613 }
20614
20615
20616 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20617 PyObject *resultobj = 0;
20618 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20619 int arg2 = (int) wxMOUSE_BTN_ANY ;
20620 bool result;
20621 void *argp1 = 0 ;
20622 int res1 = 0 ;
20623 int val2 ;
20624 int ecode2 = 0 ;
20625 PyObject * obj0 = 0 ;
20626 PyObject * obj1 = 0 ;
20627 char * kwnames[] = {
20628 (char *) "self",(char *) "but", NULL
20629 };
20630
20631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20633 if (!SWIG_IsOK(res1)) {
20634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20635 }
20636 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20637 if (obj1) {
20638 ecode2 = SWIG_AsVal_int(obj1, &val2);
20639 if (!SWIG_IsOK(ecode2)) {
20640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20641 }
20642 arg2 = static_cast< int >(val2);
20643 }
20644 {
20645 PyThreadState* __tstate = wxPyBeginAllowThreads();
20646 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20647 wxPyEndAllowThreads(__tstate);
20648 if (PyErr_Occurred()) SWIG_fail;
20649 }
20650 {
20651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20652 }
20653 return resultobj;
20654 fail:
20655 return NULL;
20656 }
20657
20658
20659 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20660 PyObject *resultobj = 0;
20661 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20662 int arg2 = (int) wxMOUSE_BTN_ANY ;
20663 bool result;
20664 void *argp1 = 0 ;
20665 int res1 = 0 ;
20666 int val2 ;
20667 int ecode2 = 0 ;
20668 PyObject * obj0 = 0 ;
20669 PyObject * obj1 = 0 ;
20670 char * kwnames[] = {
20671 (char *) "self",(char *) "but", NULL
20672 };
20673
20674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20676 if (!SWIG_IsOK(res1)) {
20677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20678 }
20679 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20680 if (obj1) {
20681 ecode2 = SWIG_AsVal_int(obj1, &val2);
20682 if (!SWIG_IsOK(ecode2)) {
20683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20684 }
20685 arg2 = static_cast< int >(val2);
20686 }
20687 {
20688 PyThreadState* __tstate = wxPyBeginAllowThreads();
20689 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20690 wxPyEndAllowThreads(__tstate);
20691 if (PyErr_Occurred()) SWIG_fail;
20692 }
20693 {
20694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20695 }
20696 return resultobj;
20697 fail:
20698 return NULL;
20699 }
20700
20701
20702 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20703 PyObject *resultobj = 0;
20704 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20705 int arg2 ;
20706 bool result;
20707 void *argp1 = 0 ;
20708 int res1 = 0 ;
20709 int val2 ;
20710 int ecode2 = 0 ;
20711 PyObject * obj0 = 0 ;
20712 PyObject * obj1 = 0 ;
20713 char * kwnames[] = {
20714 (char *) "self",(char *) "button", NULL
20715 };
20716
20717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20719 if (!SWIG_IsOK(res1)) {
20720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20721 }
20722 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20723 ecode2 = SWIG_AsVal_int(obj1, &val2);
20724 if (!SWIG_IsOK(ecode2)) {
20725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20726 }
20727 arg2 = static_cast< int >(val2);
20728 {
20729 PyThreadState* __tstate = wxPyBeginAllowThreads();
20730 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20731 wxPyEndAllowThreads(__tstate);
20732 if (PyErr_Occurred()) SWIG_fail;
20733 }
20734 {
20735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20736 }
20737 return resultobj;
20738 fail:
20739 return NULL;
20740 }
20741
20742
20743 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20744 PyObject *resultobj = 0;
20745 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20746 int arg2 ;
20747 bool result;
20748 void *argp1 = 0 ;
20749 int res1 = 0 ;
20750 int val2 ;
20751 int ecode2 = 0 ;
20752 PyObject * obj0 = 0 ;
20753 PyObject * obj1 = 0 ;
20754 char * kwnames[] = {
20755 (char *) "self",(char *) "but", NULL
20756 };
20757
20758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20760 if (!SWIG_IsOK(res1)) {
20761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20762 }
20763 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20764 ecode2 = SWIG_AsVal_int(obj1, &val2);
20765 if (!SWIG_IsOK(ecode2)) {
20766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20767 }
20768 arg2 = static_cast< int >(val2);
20769 {
20770 PyThreadState* __tstate = wxPyBeginAllowThreads();
20771 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20772 wxPyEndAllowThreads(__tstate);
20773 if (PyErr_Occurred()) SWIG_fail;
20774 }
20775 {
20776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20777 }
20778 return resultobj;
20779 fail:
20780 return NULL;
20781 }
20782
20783
20784 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20785 PyObject *resultobj = 0;
20786 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20787 int result;
20788 void *argp1 = 0 ;
20789 int res1 = 0 ;
20790 PyObject *swig_obj[1] ;
20791
20792 if (!args) SWIG_fail;
20793 swig_obj[0] = args;
20794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20795 if (!SWIG_IsOK(res1)) {
20796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20797 }
20798 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20799 {
20800 PyThreadState* __tstate = wxPyBeginAllowThreads();
20801 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20802 wxPyEndAllowThreads(__tstate);
20803 if (PyErr_Occurred()) SWIG_fail;
20804 }
20805 resultobj = SWIG_From_int(static_cast< int >(result));
20806 return resultobj;
20807 fail:
20808 return NULL;
20809 }
20810
20811
20812 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20813 PyObject *resultobj = 0;
20814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20815 bool result;
20816 void *argp1 = 0 ;
20817 int res1 = 0 ;
20818 PyObject *swig_obj[1] ;
20819
20820 if (!args) SWIG_fail;
20821 swig_obj[0] = args;
20822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20823 if (!SWIG_IsOK(res1)) {
20824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20825 }
20826 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20827 {
20828 PyThreadState* __tstate = wxPyBeginAllowThreads();
20829 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20830 wxPyEndAllowThreads(__tstate);
20831 if (PyErr_Occurred()) SWIG_fail;
20832 }
20833 {
20834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20835 }
20836 return resultobj;
20837 fail:
20838 return NULL;
20839 }
20840
20841
20842 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20843 PyObject *resultobj = 0;
20844 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20845 bool result;
20846 void *argp1 = 0 ;
20847 int res1 = 0 ;
20848 PyObject *swig_obj[1] ;
20849
20850 if (!args) SWIG_fail;
20851 swig_obj[0] = args;
20852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20853 if (!SWIG_IsOK(res1)) {
20854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20855 }
20856 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20857 {
20858 PyThreadState* __tstate = wxPyBeginAllowThreads();
20859 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20860 wxPyEndAllowThreads(__tstate);
20861 if (PyErr_Occurred()) SWIG_fail;
20862 }
20863 {
20864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20865 }
20866 return resultobj;
20867 fail:
20868 return NULL;
20869 }
20870
20871
20872 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20873 PyObject *resultobj = 0;
20874 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20875 bool result;
20876 void *argp1 = 0 ;
20877 int res1 = 0 ;
20878 PyObject *swig_obj[1] ;
20879
20880 if (!args) SWIG_fail;
20881 swig_obj[0] = args;
20882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20883 if (!SWIG_IsOK(res1)) {
20884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20885 }
20886 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20887 {
20888 PyThreadState* __tstate = wxPyBeginAllowThreads();
20889 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20890 wxPyEndAllowThreads(__tstate);
20891 if (PyErr_Occurred()) SWIG_fail;
20892 }
20893 {
20894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20895 }
20896 return resultobj;
20897 fail:
20898 return NULL;
20899 }
20900
20901
20902 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20903 PyObject *resultobj = 0;
20904 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20905 bool result;
20906 void *argp1 = 0 ;
20907 int res1 = 0 ;
20908 PyObject *swig_obj[1] ;
20909
20910 if (!args) SWIG_fail;
20911 swig_obj[0] = args;
20912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20913 if (!SWIG_IsOK(res1)) {
20914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20915 }
20916 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20917 {
20918 PyThreadState* __tstate = wxPyBeginAllowThreads();
20919 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20920 wxPyEndAllowThreads(__tstate);
20921 if (PyErr_Occurred()) SWIG_fail;
20922 }
20923 {
20924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20925 }
20926 return resultobj;
20927 fail:
20928 return NULL;
20929 }
20930
20931
20932 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20933 PyObject *resultobj = 0;
20934 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20935 bool result;
20936 void *argp1 = 0 ;
20937 int res1 = 0 ;
20938 PyObject *swig_obj[1] ;
20939
20940 if (!args) SWIG_fail;
20941 swig_obj[0] = args;
20942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20943 if (!SWIG_IsOK(res1)) {
20944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20945 }
20946 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20947 {
20948 PyThreadState* __tstate = wxPyBeginAllowThreads();
20949 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20950 wxPyEndAllowThreads(__tstate);
20951 if (PyErr_Occurred()) SWIG_fail;
20952 }
20953 {
20954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20955 }
20956 return resultobj;
20957 fail:
20958 return NULL;
20959 }
20960
20961
20962 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20963 PyObject *resultobj = 0;
20964 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20965 bool result;
20966 void *argp1 = 0 ;
20967 int res1 = 0 ;
20968 PyObject *swig_obj[1] ;
20969
20970 if (!args) SWIG_fail;
20971 swig_obj[0] = args;
20972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20973 if (!SWIG_IsOK(res1)) {
20974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20975 }
20976 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20977 {
20978 PyThreadState* __tstate = wxPyBeginAllowThreads();
20979 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20980 wxPyEndAllowThreads(__tstate);
20981 if (PyErr_Occurred()) SWIG_fail;
20982 }
20983 {
20984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20985 }
20986 return resultobj;
20987 fail:
20988 return NULL;
20989 }
20990
20991
20992 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20993 PyObject *resultobj = 0;
20994 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20995 bool result;
20996 void *argp1 = 0 ;
20997 int res1 = 0 ;
20998 PyObject *swig_obj[1] ;
20999
21000 if (!args) SWIG_fail;
21001 swig_obj[0] = args;
21002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21003 if (!SWIG_IsOK(res1)) {
21004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21005 }
21006 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21007 {
21008 PyThreadState* __tstate = wxPyBeginAllowThreads();
21009 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
21010 wxPyEndAllowThreads(__tstate);
21011 if (PyErr_Occurred()) SWIG_fail;
21012 }
21013 {
21014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21015 }
21016 return resultobj;
21017 fail:
21018 return NULL;
21019 }
21020
21021
21022 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21023 PyObject *resultobj = 0;
21024 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21025 bool result;
21026 void *argp1 = 0 ;
21027 int res1 = 0 ;
21028 PyObject *swig_obj[1] ;
21029
21030 if (!args) SWIG_fail;
21031 swig_obj[0] = args;
21032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21033 if (!SWIG_IsOK(res1)) {
21034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21035 }
21036 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21037 {
21038 PyThreadState* __tstate = wxPyBeginAllowThreads();
21039 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
21040 wxPyEndAllowThreads(__tstate);
21041 if (PyErr_Occurred()) SWIG_fail;
21042 }
21043 {
21044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21045 }
21046 return resultobj;
21047 fail:
21048 return NULL;
21049 }
21050
21051
21052 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21053 PyObject *resultobj = 0;
21054 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21055 bool result;
21056 void *argp1 = 0 ;
21057 int res1 = 0 ;
21058 PyObject *swig_obj[1] ;
21059
21060 if (!args) SWIG_fail;
21061 swig_obj[0] = args;
21062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21063 if (!SWIG_IsOK(res1)) {
21064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21065 }
21066 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21067 {
21068 PyThreadState* __tstate = wxPyBeginAllowThreads();
21069 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
21070 wxPyEndAllowThreads(__tstate);
21071 if (PyErr_Occurred()) SWIG_fail;
21072 }
21073 {
21074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21075 }
21076 return resultobj;
21077 fail:
21078 return NULL;
21079 }
21080
21081
21082 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21083 PyObject *resultobj = 0;
21084 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21085 bool result;
21086 void *argp1 = 0 ;
21087 int res1 = 0 ;
21088 PyObject *swig_obj[1] ;
21089
21090 if (!args) SWIG_fail;
21091 swig_obj[0] = args;
21092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21093 if (!SWIG_IsOK(res1)) {
21094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21095 }
21096 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21097 {
21098 PyThreadState* __tstate = wxPyBeginAllowThreads();
21099 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
21100 wxPyEndAllowThreads(__tstate);
21101 if (PyErr_Occurred()) SWIG_fail;
21102 }
21103 {
21104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21105 }
21106 return resultobj;
21107 fail:
21108 return NULL;
21109 }
21110
21111
21112 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21113 PyObject *resultobj = 0;
21114 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21115 bool result;
21116 void *argp1 = 0 ;
21117 int res1 = 0 ;
21118 PyObject *swig_obj[1] ;
21119
21120 if (!args) SWIG_fail;
21121 swig_obj[0] = args;
21122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21123 if (!SWIG_IsOK(res1)) {
21124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21125 }
21126 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21127 {
21128 PyThreadState* __tstate = wxPyBeginAllowThreads();
21129 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
21130 wxPyEndAllowThreads(__tstate);
21131 if (PyErr_Occurred()) SWIG_fail;
21132 }
21133 {
21134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21135 }
21136 return resultobj;
21137 fail:
21138 return NULL;
21139 }
21140
21141
21142 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21143 PyObject *resultobj = 0;
21144 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21145 bool result;
21146 void *argp1 = 0 ;
21147 int res1 = 0 ;
21148 PyObject *swig_obj[1] ;
21149
21150 if (!args) SWIG_fail;
21151 swig_obj[0] = args;
21152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21153 if (!SWIG_IsOK(res1)) {
21154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21155 }
21156 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21157 {
21158 PyThreadState* __tstate = wxPyBeginAllowThreads();
21159 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
21160 wxPyEndAllowThreads(__tstate);
21161 if (PyErr_Occurred()) SWIG_fail;
21162 }
21163 {
21164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21165 }
21166 return resultobj;
21167 fail:
21168 return NULL;
21169 }
21170
21171
21172 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21173 PyObject *resultobj = 0;
21174 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21175 bool result;
21176 void *argp1 = 0 ;
21177 int res1 = 0 ;
21178 PyObject *swig_obj[1] ;
21179
21180 if (!args) SWIG_fail;
21181 swig_obj[0] = args;
21182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21183 if (!SWIG_IsOK(res1)) {
21184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21185 }
21186 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21187 {
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
21190 wxPyEndAllowThreads(__tstate);
21191 if (PyErr_Occurred()) SWIG_fail;
21192 }
21193 {
21194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21195 }
21196 return resultobj;
21197 fail:
21198 return NULL;
21199 }
21200
21201
21202 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21203 PyObject *resultobj = 0;
21204 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21205 bool result;
21206 void *argp1 = 0 ;
21207 int res1 = 0 ;
21208 PyObject *swig_obj[1] ;
21209
21210 if (!args) SWIG_fail;
21211 swig_obj[0] = args;
21212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21213 if (!SWIG_IsOK(res1)) {
21214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21215 }
21216 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21217 {
21218 PyThreadState* __tstate = wxPyBeginAllowThreads();
21219 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
21220 wxPyEndAllowThreads(__tstate);
21221 if (PyErr_Occurred()) SWIG_fail;
21222 }
21223 {
21224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21225 }
21226 return resultobj;
21227 fail:
21228 return NULL;
21229 }
21230
21231
21232 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21233 PyObject *resultobj = 0;
21234 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21235 bool result;
21236 void *argp1 = 0 ;
21237 int res1 = 0 ;
21238 PyObject *swig_obj[1] ;
21239
21240 if (!args) SWIG_fail;
21241 swig_obj[0] = args;
21242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21243 if (!SWIG_IsOK(res1)) {
21244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21245 }
21246 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21247 {
21248 PyThreadState* __tstate = wxPyBeginAllowThreads();
21249 result = (bool)(arg1)->LeftIsDown();
21250 wxPyEndAllowThreads(__tstate);
21251 if (PyErr_Occurred()) SWIG_fail;
21252 }
21253 {
21254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21255 }
21256 return resultobj;
21257 fail:
21258 return NULL;
21259 }
21260
21261
21262 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21263 PyObject *resultobj = 0;
21264 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21265 bool result;
21266 void *argp1 = 0 ;
21267 int res1 = 0 ;
21268 PyObject *swig_obj[1] ;
21269
21270 if (!args) SWIG_fail;
21271 swig_obj[0] = args;
21272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21273 if (!SWIG_IsOK(res1)) {
21274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21275 }
21276 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21277 {
21278 PyThreadState* __tstate = wxPyBeginAllowThreads();
21279 result = (bool)(arg1)->MiddleIsDown();
21280 wxPyEndAllowThreads(__tstate);
21281 if (PyErr_Occurred()) SWIG_fail;
21282 }
21283 {
21284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21285 }
21286 return resultobj;
21287 fail:
21288 return NULL;
21289 }
21290
21291
21292 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21293 PyObject *resultobj = 0;
21294 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21295 bool result;
21296 void *argp1 = 0 ;
21297 int res1 = 0 ;
21298 PyObject *swig_obj[1] ;
21299
21300 if (!args) SWIG_fail;
21301 swig_obj[0] = args;
21302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21303 if (!SWIG_IsOK(res1)) {
21304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21305 }
21306 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21307 {
21308 PyThreadState* __tstate = wxPyBeginAllowThreads();
21309 result = (bool)(arg1)->RightIsDown();
21310 wxPyEndAllowThreads(__tstate);
21311 if (PyErr_Occurred()) SWIG_fail;
21312 }
21313 {
21314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21315 }
21316 return resultobj;
21317 fail:
21318 return NULL;
21319 }
21320
21321
21322 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21323 PyObject *resultobj = 0;
21324 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21325 bool result;
21326 void *argp1 = 0 ;
21327 int res1 = 0 ;
21328 PyObject *swig_obj[1] ;
21329
21330 if (!args) SWIG_fail;
21331 swig_obj[0] = args;
21332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21333 if (!SWIG_IsOK(res1)) {
21334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21335 }
21336 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21337 {
21338 PyThreadState* __tstate = wxPyBeginAllowThreads();
21339 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
21340 wxPyEndAllowThreads(__tstate);
21341 if (PyErr_Occurred()) SWIG_fail;
21342 }
21343 {
21344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21345 }
21346 return resultobj;
21347 fail:
21348 return NULL;
21349 }
21350
21351
21352 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21353 PyObject *resultobj = 0;
21354 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21355 bool result;
21356 void *argp1 = 0 ;
21357 int res1 = 0 ;
21358 PyObject *swig_obj[1] ;
21359
21360 if (!args) SWIG_fail;
21361 swig_obj[0] = args;
21362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21363 if (!SWIG_IsOK(res1)) {
21364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21365 }
21366 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21367 {
21368 PyThreadState* __tstate = wxPyBeginAllowThreads();
21369 result = (bool)((wxMouseEvent const *)arg1)->Moving();
21370 wxPyEndAllowThreads(__tstate);
21371 if (PyErr_Occurred()) SWIG_fail;
21372 }
21373 {
21374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21375 }
21376 return resultobj;
21377 fail:
21378 return NULL;
21379 }
21380
21381
21382 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21383 PyObject *resultobj = 0;
21384 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21385 bool result;
21386 void *argp1 = 0 ;
21387 int res1 = 0 ;
21388 PyObject *swig_obj[1] ;
21389
21390 if (!args) SWIG_fail;
21391 swig_obj[0] = args;
21392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21393 if (!SWIG_IsOK(res1)) {
21394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21395 }
21396 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21397 {
21398 PyThreadState* __tstate = wxPyBeginAllowThreads();
21399 result = (bool)((wxMouseEvent const *)arg1)->Entering();
21400 wxPyEndAllowThreads(__tstate);
21401 if (PyErr_Occurred()) SWIG_fail;
21402 }
21403 {
21404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21405 }
21406 return resultobj;
21407 fail:
21408 return NULL;
21409 }
21410
21411
21412 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21413 PyObject *resultobj = 0;
21414 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21415 bool result;
21416 void *argp1 = 0 ;
21417 int res1 = 0 ;
21418 PyObject *swig_obj[1] ;
21419
21420 if (!args) SWIG_fail;
21421 swig_obj[0] = args;
21422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21423 if (!SWIG_IsOK(res1)) {
21424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21425 }
21426 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21427 {
21428 PyThreadState* __tstate = wxPyBeginAllowThreads();
21429 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
21430 wxPyEndAllowThreads(__tstate);
21431 if (PyErr_Occurred()) SWIG_fail;
21432 }
21433 {
21434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21435 }
21436 return resultobj;
21437 fail:
21438 return NULL;
21439 }
21440
21441
21442 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21443 PyObject *resultobj = 0;
21444 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21445 wxPoint result;
21446 void *argp1 = 0 ;
21447 int res1 = 0 ;
21448 PyObject *swig_obj[1] ;
21449
21450 if (!args) SWIG_fail;
21451 swig_obj[0] = args;
21452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21453 if (!SWIG_IsOK(res1)) {
21454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21455 }
21456 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21457 {
21458 PyThreadState* __tstate = wxPyBeginAllowThreads();
21459 result = (arg1)->GetPosition();
21460 wxPyEndAllowThreads(__tstate);
21461 if (PyErr_Occurred()) SWIG_fail;
21462 }
21463 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21464 return resultobj;
21465 fail:
21466 return NULL;
21467 }
21468
21469
21470 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21471 PyObject *resultobj = 0;
21472 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21473 long *arg2 = (long *) 0 ;
21474 long *arg3 = (long *) 0 ;
21475 void *argp1 = 0 ;
21476 int res1 = 0 ;
21477 long temp2 ;
21478 int res2 = SWIG_TMPOBJ ;
21479 long temp3 ;
21480 int res3 = SWIG_TMPOBJ ;
21481 PyObject *swig_obj[1] ;
21482
21483 arg2 = &temp2;
21484 arg3 = &temp3;
21485 if (!args) SWIG_fail;
21486 swig_obj[0] = args;
21487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21488 if (!SWIG_IsOK(res1)) {
21489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21490 }
21491 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21492 {
21493 PyThreadState* __tstate = wxPyBeginAllowThreads();
21494 (arg1)->GetPosition(arg2,arg3);
21495 wxPyEndAllowThreads(__tstate);
21496 if (PyErr_Occurred()) SWIG_fail;
21497 }
21498 resultobj = SWIG_Py_Void();
21499 if (SWIG_IsTmpObj(res2)) {
21500 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21501 } else {
21502 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21503 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21504 }
21505 if (SWIG_IsTmpObj(res3)) {
21506 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21507 } else {
21508 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21510 }
21511 return resultobj;
21512 fail:
21513 return NULL;
21514 }
21515
21516
21517 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21518 PyObject *resultobj = 0;
21519 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21520 wxDC *arg2 = 0 ;
21521 wxPoint result;
21522 void *argp1 = 0 ;
21523 int res1 = 0 ;
21524 void *argp2 = 0 ;
21525 int res2 = 0 ;
21526 PyObject * obj0 = 0 ;
21527 PyObject * obj1 = 0 ;
21528 char * kwnames[] = {
21529 (char *) "self",(char *) "dc", NULL
21530 };
21531
21532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21534 if (!SWIG_IsOK(res1)) {
21535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21536 }
21537 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21539 if (!SWIG_IsOK(res2)) {
21540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21541 }
21542 if (!argp2) {
21543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21544 }
21545 arg2 = reinterpret_cast< wxDC * >(argp2);
21546 {
21547 PyThreadState* __tstate = wxPyBeginAllowThreads();
21548 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21549 wxPyEndAllowThreads(__tstate);
21550 if (PyErr_Occurred()) SWIG_fail;
21551 }
21552 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21553 return resultobj;
21554 fail:
21555 return NULL;
21556 }
21557
21558
21559 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21560 PyObject *resultobj = 0;
21561 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21562 int result;
21563 void *argp1 = 0 ;
21564 int res1 = 0 ;
21565 PyObject *swig_obj[1] ;
21566
21567 if (!args) SWIG_fail;
21568 swig_obj[0] = args;
21569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21570 if (!SWIG_IsOK(res1)) {
21571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21572 }
21573 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21574 {
21575 PyThreadState* __tstate = wxPyBeginAllowThreads();
21576 result = (int)((wxMouseEvent const *)arg1)->GetX();
21577 wxPyEndAllowThreads(__tstate);
21578 if (PyErr_Occurred()) SWIG_fail;
21579 }
21580 resultobj = SWIG_From_int(static_cast< int >(result));
21581 return resultobj;
21582 fail:
21583 return NULL;
21584 }
21585
21586
21587 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21588 PyObject *resultobj = 0;
21589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21590 int result;
21591 void *argp1 = 0 ;
21592 int res1 = 0 ;
21593 PyObject *swig_obj[1] ;
21594
21595 if (!args) SWIG_fail;
21596 swig_obj[0] = args;
21597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21598 if (!SWIG_IsOK(res1)) {
21599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21600 }
21601 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21602 {
21603 PyThreadState* __tstate = wxPyBeginAllowThreads();
21604 result = (int)((wxMouseEvent const *)arg1)->GetY();
21605 wxPyEndAllowThreads(__tstate);
21606 if (PyErr_Occurred()) SWIG_fail;
21607 }
21608 resultobj = SWIG_From_int(static_cast< int >(result));
21609 return resultobj;
21610 fail:
21611 return NULL;
21612 }
21613
21614
21615 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21616 PyObject *resultobj = 0;
21617 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21618 int result;
21619 void *argp1 = 0 ;
21620 int res1 = 0 ;
21621 PyObject *swig_obj[1] ;
21622
21623 if (!args) SWIG_fail;
21624 swig_obj[0] = args;
21625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21626 if (!SWIG_IsOK(res1)) {
21627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21628 }
21629 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21630 {
21631 PyThreadState* __tstate = wxPyBeginAllowThreads();
21632 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21633 wxPyEndAllowThreads(__tstate);
21634 if (PyErr_Occurred()) SWIG_fail;
21635 }
21636 resultobj = SWIG_From_int(static_cast< int >(result));
21637 return resultobj;
21638 fail:
21639 return NULL;
21640 }
21641
21642
21643 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21644 PyObject *resultobj = 0;
21645 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21646 int result;
21647 void *argp1 = 0 ;
21648 int res1 = 0 ;
21649 PyObject *swig_obj[1] ;
21650
21651 if (!args) SWIG_fail;
21652 swig_obj[0] = args;
21653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21654 if (!SWIG_IsOK(res1)) {
21655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21656 }
21657 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21658 {
21659 PyThreadState* __tstate = wxPyBeginAllowThreads();
21660 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21661 wxPyEndAllowThreads(__tstate);
21662 if (PyErr_Occurred()) SWIG_fail;
21663 }
21664 resultobj = SWIG_From_int(static_cast< int >(result));
21665 return resultobj;
21666 fail:
21667 return NULL;
21668 }
21669
21670
21671 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21672 PyObject *resultobj = 0;
21673 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21674 int result;
21675 void *argp1 = 0 ;
21676 int res1 = 0 ;
21677 PyObject *swig_obj[1] ;
21678
21679 if (!args) SWIG_fail;
21680 swig_obj[0] = args;
21681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21682 if (!SWIG_IsOK(res1)) {
21683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21684 }
21685 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21686 {
21687 PyThreadState* __tstate = wxPyBeginAllowThreads();
21688 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21689 wxPyEndAllowThreads(__tstate);
21690 if (PyErr_Occurred()) SWIG_fail;
21691 }
21692 resultobj = SWIG_From_int(static_cast< int >(result));
21693 return resultobj;
21694 fail:
21695 return NULL;
21696 }
21697
21698
21699 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21700 PyObject *resultobj = 0;
21701 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21702 bool result;
21703 void *argp1 = 0 ;
21704 int res1 = 0 ;
21705 PyObject *swig_obj[1] ;
21706
21707 if (!args) SWIG_fail;
21708 swig_obj[0] = args;
21709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21710 if (!SWIG_IsOK(res1)) {
21711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21712 }
21713 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21714 {
21715 PyThreadState* __tstate = wxPyBeginAllowThreads();
21716 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21717 wxPyEndAllowThreads(__tstate);
21718 if (PyErr_Occurred()) SWIG_fail;
21719 }
21720 {
21721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21722 }
21723 return resultobj;
21724 fail:
21725 return NULL;
21726 }
21727
21728
21729 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21730 PyObject *resultobj = 0;
21731 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21732 int arg2 ;
21733 void *argp1 = 0 ;
21734 int res1 = 0 ;
21735 int val2 ;
21736 int ecode2 = 0 ;
21737 PyObject *swig_obj[2] ;
21738
21739 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21741 if (!SWIG_IsOK(res1)) {
21742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21743 }
21744 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21745 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21746 if (!SWIG_IsOK(ecode2)) {
21747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21748 }
21749 arg2 = static_cast< int >(val2);
21750 if (arg1) (arg1)->m_x = arg2;
21751
21752 resultobj = SWIG_Py_Void();
21753 return resultobj;
21754 fail:
21755 return NULL;
21756 }
21757
21758
21759 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21760 PyObject *resultobj = 0;
21761 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21762 int result;
21763 void *argp1 = 0 ;
21764 int res1 = 0 ;
21765 PyObject *swig_obj[1] ;
21766
21767 if (!args) SWIG_fail;
21768 swig_obj[0] = args;
21769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21770 if (!SWIG_IsOK(res1)) {
21771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21772 }
21773 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21774 result = (int) ((arg1)->m_x);
21775 resultobj = SWIG_From_int(static_cast< int >(result));
21776 return resultobj;
21777 fail:
21778 return NULL;
21779 }
21780
21781
21782 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21783 PyObject *resultobj = 0;
21784 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21785 int arg2 ;
21786 void *argp1 = 0 ;
21787 int res1 = 0 ;
21788 int val2 ;
21789 int ecode2 = 0 ;
21790 PyObject *swig_obj[2] ;
21791
21792 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21794 if (!SWIG_IsOK(res1)) {
21795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21796 }
21797 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21798 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21799 if (!SWIG_IsOK(ecode2)) {
21800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21801 }
21802 arg2 = static_cast< int >(val2);
21803 if (arg1) (arg1)->m_y = arg2;
21804
21805 resultobj = SWIG_Py_Void();
21806 return resultobj;
21807 fail:
21808 return NULL;
21809 }
21810
21811
21812 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21813 PyObject *resultobj = 0;
21814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21815 int result;
21816 void *argp1 = 0 ;
21817 int res1 = 0 ;
21818 PyObject *swig_obj[1] ;
21819
21820 if (!args) SWIG_fail;
21821 swig_obj[0] = args;
21822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21823 if (!SWIG_IsOK(res1)) {
21824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21825 }
21826 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21827 result = (int) ((arg1)->m_y);
21828 resultobj = SWIG_From_int(static_cast< int >(result));
21829 return resultobj;
21830 fail:
21831 return NULL;
21832 }
21833
21834
21835 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21836 PyObject *resultobj = 0;
21837 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21838 bool arg2 ;
21839 void *argp1 = 0 ;
21840 int res1 = 0 ;
21841 bool val2 ;
21842 int ecode2 = 0 ;
21843 PyObject *swig_obj[2] ;
21844
21845 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21847 if (!SWIG_IsOK(res1)) {
21848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21849 }
21850 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21851 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21852 if (!SWIG_IsOK(ecode2)) {
21853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21854 }
21855 arg2 = static_cast< bool >(val2);
21856 if (arg1) (arg1)->m_leftDown = arg2;
21857
21858 resultobj = SWIG_Py_Void();
21859 return resultobj;
21860 fail:
21861 return NULL;
21862 }
21863
21864
21865 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21866 PyObject *resultobj = 0;
21867 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21868 bool result;
21869 void *argp1 = 0 ;
21870 int res1 = 0 ;
21871 PyObject *swig_obj[1] ;
21872
21873 if (!args) SWIG_fail;
21874 swig_obj[0] = args;
21875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21876 if (!SWIG_IsOK(res1)) {
21877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21878 }
21879 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21880 result = (bool) ((arg1)->m_leftDown);
21881 {
21882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21883 }
21884 return resultobj;
21885 fail:
21886 return NULL;
21887 }
21888
21889
21890 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21891 PyObject *resultobj = 0;
21892 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21893 bool arg2 ;
21894 void *argp1 = 0 ;
21895 int res1 = 0 ;
21896 bool val2 ;
21897 int ecode2 = 0 ;
21898 PyObject *swig_obj[2] ;
21899
21900 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21902 if (!SWIG_IsOK(res1)) {
21903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21904 }
21905 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21906 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21907 if (!SWIG_IsOK(ecode2)) {
21908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21909 }
21910 arg2 = static_cast< bool >(val2);
21911 if (arg1) (arg1)->m_middleDown = arg2;
21912
21913 resultobj = SWIG_Py_Void();
21914 return resultobj;
21915 fail:
21916 return NULL;
21917 }
21918
21919
21920 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21921 PyObject *resultobj = 0;
21922 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21923 bool result;
21924 void *argp1 = 0 ;
21925 int res1 = 0 ;
21926 PyObject *swig_obj[1] ;
21927
21928 if (!args) SWIG_fail;
21929 swig_obj[0] = args;
21930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21931 if (!SWIG_IsOK(res1)) {
21932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21933 }
21934 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21935 result = (bool) ((arg1)->m_middleDown);
21936 {
21937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21938 }
21939 return resultobj;
21940 fail:
21941 return NULL;
21942 }
21943
21944
21945 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21946 PyObject *resultobj = 0;
21947 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21948 bool arg2 ;
21949 void *argp1 = 0 ;
21950 int res1 = 0 ;
21951 bool val2 ;
21952 int ecode2 = 0 ;
21953 PyObject *swig_obj[2] ;
21954
21955 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21957 if (!SWIG_IsOK(res1)) {
21958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21959 }
21960 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21961 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21962 if (!SWIG_IsOK(ecode2)) {
21963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21964 }
21965 arg2 = static_cast< bool >(val2);
21966 if (arg1) (arg1)->m_rightDown = arg2;
21967
21968 resultobj = SWIG_Py_Void();
21969 return resultobj;
21970 fail:
21971 return NULL;
21972 }
21973
21974
21975 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21976 PyObject *resultobj = 0;
21977 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21978 bool result;
21979 void *argp1 = 0 ;
21980 int res1 = 0 ;
21981 PyObject *swig_obj[1] ;
21982
21983 if (!args) SWIG_fail;
21984 swig_obj[0] = args;
21985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21986 if (!SWIG_IsOK(res1)) {
21987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21988 }
21989 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21990 result = (bool) ((arg1)->m_rightDown);
21991 {
21992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21993 }
21994 return resultobj;
21995 fail:
21996 return NULL;
21997 }
21998
21999
22000 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22001 PyObject *resultobj = 0;
22002 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22003 bool arg2 ;
22004 void *argp1 = 0 ;
22005 int res1 = 0 ;
22006 bool val2 ;
22007 int ecode2 = 0 ;
22008 PyObject *swig_obj[2] ;
22009
22010 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22012 if (!SWIG_IsOK(res1)) {
22013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22014 }
22015 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22016 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22017 if (!SWIG_IsOK(ecode2)) {
22018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22019 }
22020 arg2 = static_cast< bool >(val2);
22021 if (arg1) (arg1)->m_controlDown = arg2;
22022
22023 resultobj = SWIG_Py_Void();
22024 return resultobj;
22025 fail:
22026 return NULL;
22027 }
22028
22029
22030 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22031 PyObject *resultobj = 0;
22032 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22033 bool result;
22034 void *argp1 = 0 ;
22035 int res1 = 0 ;
22036 PyObject *swig_obj[1] ;
22037
22038 if (!args) SWIG_fail;
22039 swig_obj[0] = args;
22040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22041 if (!SWIG_IsOK(res1)) {
22042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22043 }
22044 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22045 result = (bool) ((arg1)->m_controlDown);
22046 {
22047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22048 }
22049 return resultobj;
22050 fail:
22051 return NULL;
22052 }
22053
22054
22055 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22056 PyObject *resultobj = 0;
22057 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22058 bool arg2 ;
22059 void *argp1 = 0 ;
22060 int res1 = 0 ;
22061 bool val2 ;
22062 int ecode2 = 0 ;
22063 PyObject *swig_obj[2] ;
22064
22065 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22067 if (!SWIG_IsOK(res1)) {
22068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22069 }
22070 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22071 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22072 if (!SWIG_IsOK(ecode2)) {
22073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22074 }
22075 arg2 = static_cast< bool >(val2);
22076 if (arg1) (arg1)->m_shiftDown = arg2;
22077
22078 resultobj = SWIG_Py_Void();
22079 return resultobj;
22080 fail:
22081 return NULL;
22082 }
22083
22084
22085 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22086 PyObject *resultobj = 0;
22087 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22088 bool result;
22089 void *argp1 = 0 ;
22090 int res1 = 0 ;
22091 PyObject *swig_obj[1] ;
22092
22093 if (!args) SWIG_fail;
22094 swig_obj[0] = args;
22095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22096 if (!SWIG_IsOK(res1)) {
22097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22098 }
22099 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22100 result = (bool) ((arg1)->m_shiftDown);
22101 {
22102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22103 }
22104 return resultobj;
22105 fail:
22106 return NULL;
22107 }
22108
22109
22110 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22111 PyObject *resultobj = 0;
22112 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22113 bool arg2 ;
22114 void *argp1 = 0 ;
22115 int res1 = 0 ;
22116 bool val2 ;
22117 int ecode2 = 0 ;
22118 PyObject *swig_obj[2] ;
22119
22120 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22122 if (!SWIG_IsOK(res1)) {
22123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22124 }
22125 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22126 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22127 if (!SWIG_IsOK(ecode2)) {
22128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22129 }
22130 arg2 = static_cast< bool >(val2);
22131 if (arg1) (arg1)->m_altDown = arg2;
22132
22133 resultobj = SWIG_Py_Void();
22134 return resultobj;
22135 fail:
22136 return NULL;
22137 }
22138
22139
22140 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22141 PyObject *resultobj = 0;
22142 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22143 bool result;
22144 void *argp1 = 0 ;
22145 int res1 = 0 ;
22146 PyObject *swig_obj[1] ;
22147
22148 if (!args) SWIG_fail;
22149 swig_obj[0] = args;
22150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22151 if (!SWIG_IsOK(res1)) {
22152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22153 }
22154 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22155 result = (bool) ((arg1)->m_altDown);
22156 {
22157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22158 }
22159 return resultobj;
22160 fail:
22161 return NULL;
22162 }
22163
22164
22165 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22166 PyObject *resultobj = 0;
22167 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22168 bool arg2 ;
22169 void *argp1 = 0 ;
22170 int res1 = 0 ;
22171 bool val2 ;
22172 int ecode2 = 0 ;
22173 PyObject *swig_obj[2] ;
22174
22175 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22177 if (!SWIG_IsOK(res1)) {
22178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22179 }
22180 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22181 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22182 if (!SWIG_IsOK(ecode2)) {
22183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22184 }
22185 arg2 = static_cast< bool >(val2);
22186 if (arg1) (arg1)->m_metaDown = arg2;
22187
22188 resultobj = SWIG_Py_Void();
22189 return resultobj;
22190 fail:
22191 return NULL;
22192 }
22193
22194
22195 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22196 PyObject *resultobj = 0;
22197 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22198 bool result;
22199 void *argp1 = 0 ;
22200 int res1 = 0 ;
22201 PyObject *swig_obj[1] ;
22202
22203 if (!args) SWIG_fail;
22204 swig_obj[0] = args;
22205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22206 if (!SWIG_IsOK(res1)) {
22207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22208 }
22209 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22210 result = (bool) ((arg1)->m_metaDown);
22211 {
22212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22213 }
22214 return resultobj;
22215 fail:
22216 return NULL;
22217 }
22218
22219
22220 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22221 PyObject *resultobj = 0;
22222 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22223 int arg2 ;
22224 void *argp1 = 0 ;
22225 int res1 = 0 ;
22226 int val2 ;
22227 int ecode2 = 0 ;
22228 PyObject *swig_obj[2] ;
22229
22230 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
22231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22232 if (!SWIG_IsOK(res1)) {
22233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22234 }
22235 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22236 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22237 if (!SWIG_IsOK(ecode2)) {
22238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
22239 }
22240 arg2 = static_cast< int >(val2);
22241 if (arg1) (arg1)->m_wheelRotation = arg2;
22242
22243 resultobj = SWIG_Py_Void();
22244 return resultobj;
22245 fail:
22246 return NULL;
22247 }
22248
22249
22250 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22251 PyObject *resultobj = 0;
22252 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22253 int result;
22254 void *argp1 = 0 ;
22255 int res1 = 0 ;
22256 PyObject *swig_obj[1] ;
22257
22258 if (!args) SWIG_fail;
22259 swig_obj[0] = args;
22260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22261 if (!SWIG_IsOK(res1)) {
22262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22263 }
22264 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22265 result = (int) ((arg1)->m_wheelRotation);
22266 resultobj = SWIG_From_int(static_cast< int >(result));
22267 return resultobj;
22268 fail:
22269 return NULL;
22270 }
22271
22272
22273 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22274 PyObject *resultobj = 0;
22275 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22276 int arg2 ;
22277 void *argp1 = 0 ;
22278 int res1 = 0 ;
22279 int val2 ;
22280 int ecode2 = 0 ;
22281 PyObject *swig_obj[2] ;
22282
22283 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
22284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22285 if (!SWIG_IsOK(res1)) {
22286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22287 }
22288 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22289 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22290 if (!SWIG_IsOK(ecode2)) {
22291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
22292 }
22293 arg2 = static_cast< int >(val2);
22294 if (arg1) (arg1)->m_wheelDelta = arg2;
22295
22296 resultobj = SWIG_Py_Void();
22297 return resultobj;
22298 fail:
22299 return NULL;
22300 }
22301
22302
22303 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22304 PyObject *resultobj = 0;
22305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22306 int result;
22307 void *argp1 = 0 ;
22308 int res1 = 0 ;
22309 PyObject *swig_obj[1] ;
22310
22311 if (!args) SWIG_fail;
22312 swig_obj[0] = args;
22313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22314 if (!SWIG_IsOK(res1)) {
22315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22316 }
22317 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22318 result = (int) ((arg1)->m_wheelDelta);
22319 resultobj = SWIG_From_int(static_cast< int >(result));
22320 return resultobj;
22321 fail:
22322 return NULL;
22323 }
22324
22325
22326 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22327 PyObject *resultobj = 0;
22328 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22329 int arg2 ;
22330 void *argp1 = 0 ;
22331 int res1 = 0 ;
22332 int val2 ;
22333 int ecode2 = 0 ;
22334 PyObject *swig_obj[2] ;
22335
22336 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
22337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22338 if (!SWIG_IsOK(res1)) {
22339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22340 }
22341 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22342 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22343 if (!SWIG_IsOK(ecode2)) {
22344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
22345 }
22346 arg2 = static_cast< int >(val2);
22347 if (arg1) (arg1)->m_linesPerAction = arg2;
22348
22349 resultobj = SWIG_Py_Void();
22350 return resultobj;
22351 fail:
22352 return NULL;
22353 }
22354
22355
22356 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22357 PyObject *resultobj = 0;
22358 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22359 int result;
22360 void *argp1 = 0 ;
22361 int res1 = 0 ;
22362 PyObject *swig_obj[1] ;
22363
22364 if (!args) SWIG_fail;
22365 swig_obj[0] = args;
22366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22367 if (!SWIG_IsOK(res1)) {
22368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22369 }
22370 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22371 result = (int) ((arg1)->m_linesPerAction);
22372 resultobj = SWIG_From_int(static_cast< int >(result));
22373 return resultobj;
22374 fail:
22375 return NULL;
22376 }
22377
22378
22379 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22380 PyObject *obj;
22381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22382 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
22383 return SWIG_Py_Void();
22384 }
22385
22386 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22387 return SWIG_Python_InitShadowInstance(args);
22388 }
22389
22390 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22391 PyObject *resultobj = 0;
22392 int arg1 = (int) 0 ;
22393 int arg2 = (int) 0 ;
22394 wxSetCursorEvent *result = 0 ;
22395 int val1 ;
22396 int ecode1 = 0 ;
22397 int val2 ;
22398 int ecode2 = 0 ;
22399 PyObject * obj0 = 0 ;
22400 PyObject * obj1 = 0 ;
22401 char * kwnames[] = {
22402 (char *) "x",(char *) "y", NULL
22403 };
22404
22405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22406 if (obj0) {
22407 ecode1 = SWIG_AsVal_int(obj0, &val1);
22408 if (!SWIG_IsOK(ecode1)) {
22409 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
22410 }
22411 arg1 = static_cast< int >(val1);
22412 }
22413 if (obj1) {
22414 ecode2 = SWIG_AsVal_int(obj1, &val2);
22415 if (!SWIG_IsOK(ecode2)) {
22416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
22417 }
22418 arg2 = static_cast< int >(val2);
22419 }
22420 {
22421 PyThreadState* __tstate = wxPyBeginAllowThreads();
22422 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
22423 wxPyEndAllowThreads(__tstate);
22424 if (PyErr_Occurred()) SWIG_fail;
22425 }
22426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
22427 return resultobj;
22428 fail:
22429 return NULL;
22430 }
22431
22432
22433 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22434 PyObject *resultobj = 0;
22435 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22436 int result;
22437 void *argp1 = 0 ;
22438 int res1 = 0 ;
22439 PyObject *swig_obj[1] ;
22440
22441 if (!args) SWIG_fail;
22442 swig_obj[0] = args;
22443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22444 if (!SWIG_IsOK(res1)) {
22445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22446 }
22447 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22448 {
22449 PyThreadState* __tstate = wxPyBeginAllowThreads();
22450 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22451 wxPyEndAllowThreads(__tstate);
22452 if (PyErr_Occurred()) SWIG_fail;
22453 }
22454 resultobj = SWIG_From_int(static_cast< int >(result));
22455 return resultobj;
22456 fail:
22457 return NULL;
22458 }
22459
22460
22461 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22462 PyObject *resultobj = 0;
22463 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22464 int result;
22465 void *argp1 = 0 ;
22466 int res1 = 0 ;
22467 PyObject *swig_obj[1] ;
22468
22469 if (!args) SWIG_fail;
22470 swig_obj[0] = args;
22471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22472 if (!SWIG_IsOK(res1)) {
22473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22474 }
22475 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22476 {
22477 PyThreadState* __tstate = wxPyBeginAllowThreads();
22478 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22479 wxPyEndAllowThreads(__tstate);
22480 if (PyErr_Occurred()) SWIG_fail;
22481 }
22482 resultobj = SWIG_From_int(static_cast< int >(result));
22483 return resultobj;
22484 fail:
22485 return NULL;
22486 }
22487
22488
22489 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22490 PyObject *resultobj = 0;
22491 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22492 wxCursor *arg2 = 0 ;
22493 void *argp1 = 0 ;
22494 int res1 = 0 ;
22495 void *argp2 = 0 ;
22496 int res2 = 0 ;
22497 PyObject * obj0 = 0 ;
22498 PyObject * obj1 = 0 ;
22499 char * kwnames[] = {
22500 (char *) "self",(char *) "cursor", NULL
22501 };
22502
22503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22505 if (!SWIG_IsOK(res1)) {
22506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22507 }
22508 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22509 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22510 if (!SWIG_IsOK(res2)) {
22511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22512 }
22513 if (!argp2) {
22514 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22515 }
22516 arg2 = reinterpret_cast< wxCursor * >(argp2);
22517 {
22518 PyThreadState* __tstate = wxPyBeginAllowThreads();
22519 (arg1)->SetCursor((wxCursor const &)*arg2);
22520 wxPyEndAllowThreads(__tstate);
22521 if (PyErr_Occurred()) SWIG_fail;
22522 }
22523 resultobj = SWIG_Py_Void();
22524 return resultobj;
22525 fail:
22526 return NULL;
22527 }
22528
22529
22530 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22531 PyObject *resultobj = 0;
22532 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22533 wxCursor *result = 0 ;
22534 void *argp1 = 0 ;
22535 int res1 = 0 ;
22536 PyObject *swig_obj[1] ;
22537
22538 if (!args) SWIG_fail;
22539 swig_obj[0] = args;
22540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22541 if (!SWIG_IsOK(res1)) {
22542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22543 }
22544 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22545 {
22546 PyThreadState* __tstate = wxPyBeginAllowThreads();
22547 {
22548 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22549 result = (wxCursor *) &_result_ref;
22550 }
22551 wxPyEndAllowThreads(__tstate);
22552 if (PyErr_Occurred()) SWIG_fail;
22553 }
22554 {
22555 wxCursor* resultptr = new wxCursor(*result);
22556 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22557 }
22558 return resultobj;
22559 fail:
22560 return NULL;
22561 }
22562
22563
22564 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22565 PyObject *resultobj = 0;
22566 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22567 bool result;
22568 void *argp1 = 0 ;
22569 int res1 = 0 ;
22570 PyObject *swig_obj[1] ;
22571
22572 if (!args) SWIG_fail;
22573 swig_obj[0] = args;
22574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22575 if (!SWIG_IsOK(res1)) {
22576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22577 }
22578 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22579 {
22580 PyThreadState* __tstate = wxPyBeginAllowThreads();
22581 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22582 wxPyEndAllowThreads(__tstate);
22583 if (PyErr_Occurred()) SWIG_fail;
22584 }
22585 {
22586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22587 }
22588 return resultobj;
22589 fail:
22590 return NULL;
22591 }
22592
22593
22594 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22595 PyObject *obj;
22596 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22597 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22598 return SWIG_Py_Void();
22599 }
22600
22601 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22602 return SWIG_Python_InitShadowInstance(args);
22603 }
22604
22605 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22606 PyObject *resultobj = 0;
22607 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22608 wxKeyEvent *result = 0 ;
22609 int val1 ;
22610 int ecode1 = 0 ;
22611 PyObject * obj0 = 0 ;
22612 char * kwnames[] = {
22613 (char *) "eventType", NULL
22614 };
22615
22616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22617 if (obj0) {
22618 ecode1 = SWIG_AsVal_int(obj0, &val1);
22619 if (!SWIG_IsOK(ecode1)) {
22620 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22621 }
22622 arg1 = static_cast< wxEventType >(val1);
22623 }
22624 {
22625 PyThreadState* __tstate = wxPyBeginAllowThreads();
22626 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22627 wxPyEndAllowThreads(__tstate);
22628 if (PyErr_Occurred()) SWIG_fail;
22629 }
22630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22631 return resultobj;
22632 fail:
22633 return NULL;
22634 }
22635
22636
22637 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22638 PyObject *resultobj = 0;
22639 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22640 int result;
22641 void *argp1 = 0 ;
22642 int res1 = 0 ;
22643 PyObject *swig_obj[1] ;
22644
22645 if (!args) SWIG_fail;
22646 swig_obj[0] = args;
22647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22648 if (!SWIG_IsOK(res1)) {
22649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22650 }
22651 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22652 {
22653 PyThreadState* __tstate = wxPyBeginAllowThreads();
22654 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22655 wxPyEndAllowThreads(__tstate);
22656 if (PyErr_Occurred()) SWIG_fail;
22657 }
22658 resultobj = SWIG_From_int(static_cast< int >(result));
22659 return resultobj;
22660 fail:
22661 return NULL;
22662 }
22663
22664
22665 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22666 PyObject *resultobj = 0;
22667 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22668 bool result;
22669 void *argp1 = 0 ;
22670 int res1 = 0 ;
22671 PyObject *swig_obj[1] ;
22672
22673 if (!args) SWIG_fail;
22674 swig_obj[0] = args;
22675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22676 if (!SWIG_IsOK(res1)) {
22677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22678 }
22679 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22680 {
22681 PyThreadState* __tstate = wxPyBeginAllowThreads();
22682 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22683 wxPyEndAllowThreads(__tstate);
22684 if (PyErr_Occurred()) SWIG_fail;
22685 }
22686 {
22687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22688 }
22689 return resultobj;
22690 fail:
22691 return NULL;
22692 }
22693
22694
22695 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22696 PyObject *resultobj = 0;
22697 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22698 bool result;
22699 void *argp1 = 0 ;
22700 int res1 = 0 ;
22701 PyObject *swig_obj[1] ;
22702
22703 if (!args) SWIG_fail;
22704 swig_obj[0] = args;
22705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22706 if (!SWIG_IsOK(res1)) {
22707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22708 }
22709 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22710 {
22711 PyThreadState* __tstate = wxPyBeginAllowThreads();
22712 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22713 wxPyEndAllowThreads(__tstate);
22714 if (PyErr_Occurred()) SWIG_fail;
22715 }
22716 {
22717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22718 }
22719 return resultobj;
22720 fail:
22721 return NULL;
22722 }
22723
22724
22725 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22726 PyObject *resultobj = 0;
22727 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22728 bool result;
22729 void *argp1 = 0 ;
22730 int res1 = 0 ;
22731 PyObject *swig_obj[1] ;
22732
22733 if (!args) SWIG_fail;
22734 swig_obj[0] = args;
22735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22736 if (!SWIG_IsOK(res1)) {
22737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22738 }
22739 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22740 {
22741 PyThreadState* __tstate = wxPyBeginAllowThreads();
22742 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22743 wxPyEndAllowThreads(__tstate);
22744 if (PyErr_Occurred()) SWIG_fail;
22745 }
22746 {
22747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22748 }
22749 return resultobj;
22750 fail:
22751 return NULL;
22752 }
22753
22754
22755 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22756 PyObject *resultobj = 0;
22757 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22758 bool result;
22759 void *argp1 = 0 ;
22760 int res1 = 0 ;
22761 PyObject *swig_obj[1] ;
22762
22763 if (!args) SWIG_fail;
22764 swig_obj[0] = args;
22765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22766 if (!SWIG_IsOK(res1)) {
22767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22768 }
22769 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22770 {
22771 PyThreadState* __tstate = wxPyBeginAllowThreads();
22772 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22773 wxPyEndAllowThreads(__tstate);
22774 if (PyErr_Occurred()) SWIG_fail;
22775 }
22776 {
22777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22778 }
22779 return resultobj;
22780 fail:
22781 return NULL;
22782 }
22783
22784
22785 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22786 PyObject *resultobj = 0;
22787 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22788 bool result;
22789 void *argp1 = 0 ;
22790 int res1 = 0 ;
22791 PyObject *swig_obj[1] ;
22792
22793 if (!args) SWIG_fail;
22794 swig_obj[0] = args;
22795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22796 if (!SWIG_IsOK(res1)) {
22797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22798 }
22799 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22800 {
22801 PyThreadState* __tstate = wxPyBeginAllowThreads();
22802 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22803 wxPyEndAllowThreads(__tstate);
22804 if (PyErr_Occurred()) SWIG_fail;
22805 }
22806 {
22807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22808 }
22809 return resultobj;
22810 fail:
22811 return NULL;
22812 }
22813
22814
22815 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22816 PyObject *resultobj = 0;
22817 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22818 bool result;
22819 void *argp1 = 0 ;
22820 int res1 = 0 ;
22821 PyObject *swig_obj[1] ;
22822
22823 if (!args) SWIG_fail;
22824 swig_obj[0] = args;
22825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22826 if (!SWIG_IsOK(res1)) {
22827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22828 }
22829 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22830 {
22831 PyThreadState* __tstate = wxPyBeginAllowThreads();
22832 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22833 wxPyEndAllowThreads(__tstate);
22834 if (PyErr_Occurred()) SWIG_fail;
22835 }
22836 {
22837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22838 }
22839 return resultobj;
22840 fail:
22841 return NULL;
22842 }
22843
22844
22845 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22846 PyObject *resultobj = 0;
22847 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22848 int result;
22849 void *argp1 = 0 ;
22850 int res1 = 0 ;
22851 PyObject *swig_obj[1] ;
22852
22853 if (!args) SWIG_fail;
22854 swig_obj[0] = args;
22855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22856 if (!SWIG_IsOK(res1)) {
22857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22858 }
22859 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22860 {
22861 PyThreadState* __tstate = wxPyBeginAllowThreads();
22862 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22863 wxPyEndAllowThreads(__tstate);
22864 if (PyErr_Occurred()) SWIG_fail;
22865 }
22866 resultobj = SWIG_From_int(static_cast< int >(result));
22867 return resultobj;
22868 fail:
22869 return NULL;
22870 }
22871
22872
22873 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22874 PyObject *resultobj = 0;
22875 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22876 int result;
22877 void *argp1 = 0 ;
22878 int res1 = 0 ;
22879 PyObject *swig_obj[1] ;
22880
22881 if (!args) SWIG_fail;
22882 swig_obj[0] = args;
22883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22884 if (!SWIG_IsOK(res1)) {
22885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22886 }
22887 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22888 {
22889 PyThreadState* __tstate = wxPyBeginAllowThreads();
22890 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22891 wxPyEndAllowThreads(__tstate);
22892 if (PyErr_Occurred()) SWIG_fail;
22893 }
22894 resultobj = SWIG_From_int(static_cast< int >(result));
22895 return resultobj;
22896 fail:
22897 return NULL;
22898 }
22899
22900
22901 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22902 PyObject *resultobj = 0;
22903 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22904 int arg2 ;
22905 void *argp1 = 0 ;
22906 int res1 = 0 ;
22907 int val2 ;
22908 int ecode2 = 0 ;
22909 PyObject * obj0 = 0 ;
22910 PyObject * obj1 = 0 ;
22911 char * kwnames[] = {
22912 (char *) "self",(char *) "uniChar", NULL
22913 };
22914
22915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22917 if (!SWIG_IsOK(res1)) {
22918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22919 }
22920 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22921 ecode2 = SWIG_AsVal_int(obj1, &val2);
22922 if (!SWIG_IsOK(ecode2)) {
22923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22924 }
22925 arg2 = static_cast< int >(val2);
22926 {
22927 PyThreadState* __tstate = wxPyBeginAllowThreads();
22928 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22929 wxPyEndAllowThreads(__tstate);
22930 if (PyErr_Occurred()) SWIG_fail;
22931 }
22932 resultobj = SWIG_Py_Void();
22933 return resultobj;
22934 fail:
22935 return NULL;
22936 }
22937
22938
22939 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22940 PyObject *resultobj = 0;
22941 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22942 unsigned int result;
22943 void *argp1 = 0 ;
22944 int res1 = 0 ;
22945 PyObject *swig_obj[1] ;
22946
22947 if (!args) SWIG_fail;
22948 swig_obj[0] = args;
22949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22950 if (!SWIG_IsOK(res1)) {
22951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22952 }
22953 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22954 {
22955 PyThreadState* __tstate = wxPyBeginAllowThreads();
22956 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22957 wxPyEndAllowThreads(__tstate);
22958 if (PyErr_Occurred()) SWIG_fail;
22959 }
22960 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22961 return resultobj;
22962 fail:
22963 return NULL;
22964 }
22965
22966
22967 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22968 PyObject *resultobj = 0;
22969 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22970 unsigned int result;
22971 void *argp1 = 0 ;
22972 int res1 = 0 ;
22973 PyObject *swig_obj[1] ;
22974
22975 if (!args) SWIG_fail;
22976 swig_obj[0] = args;
22977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22978 if (!SWIG_IsOK(res1)) {
22979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22980 }
22981 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22982 {
22983 PyThreadState* __tstate = wxPyBeginAllowThreads();
22984 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22985 wxPyEndAllowThreads(__tstate);
22986 if (PyErr_Occurred()) SWIG_fail;
22987 }
22988 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22989 return resultobj;
22990 fail:
22991 return NULL;
22992 }
22993
22994
22995 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22996 PyObject *resultobj = 0;
22997 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22998 wxPoint result;
22999 void *argp1 = 0 ;
23000 int res1 = 0 ;
23001 PyObject *swig_obj[1] ;
23002
23003 if (!args) SWIG_fail;
23004 swig_obj[0] = args;
23005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23006 if (!SWIG_IsOK(res1)) {
23007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23008 }
23009 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23010 {
23011 PyThreadState* __tstate = wxPyBeginAllowThreads();
23012 result = (arg1)->GetPosition();
23013 wxPyEndAllowThreads(__tstate);
23014 if (PyErr_Occurred()) SWIG_fail;
23015 }
23016 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23017 return resultobj;
23018 fail:
23019 return NULL;
23020 }
23021
23022
23023 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23024 PyObject *resultobj = 0;
23025 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23026 long *arg2 = (long *) 0 ;
23027 long *arg3 = (long *) 0 ;
23028 void *argp1 = 0 ;
23029 int res1 = 0 ;
23030 long temp2 ;
23031 int res2 = SWIG_TMPOBJ ;
23032 long temp3 ;
23033 int res3 = SWIG_TMPOBJ ;
23034 PyObject *swig_obj[1] ;
23035
23036 arg2 = &temp2;
23037 arg3 = &temp3;
23038 if (!args) SWIG_fail;
23039 swig_obj[0] = args;
23040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23041 if (!SWIG_IsOK(res1)) {
23042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23043 }
23044 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23045 {
23046 PyThreadState* __tstate = wxPyBeginAllowThreads();
23047 (arg1)->GetPosition(arg2,arg3);
23048 wxPyEndAllowThreads(__tstate);
23049 if (PyErr_Occurred()) SWIG_fail;
23050 }
23051 resultobj = SWIG_Py_Void();
23052 if (SWIG_IsTmpObj(res2)) {
23053 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23054 } else {
23055 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23056 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23057 }
23058 if (SWIG_IsTmpObj(res3)) {
23059 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23060 } else {
23061 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23062 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23063 }
23064 return resultobj;
23065 fail:
23066 return NULL;
23067 }
23068
23069
23070 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23071 PyObject *resultobj = 0;
23072 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23073 int result;
23074 void *argp1 = 0 ;
23075 int res1 = 0 ;
23076 PyObject *swig_obj[1] ;
23077
23078 if (!args) SWIG_fail;
23079 swig_obj[0] = args;
23080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23081 if (!SWIG_IsOK(res1)) {
23082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23083 }
23084 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23085 {
23086 PyThreadState* __tstate = wxPyBeginAllowThreads();
23087 result = (int)((wxKeyEvent const *)arg1)->GetX();
23088 wxPyEndAllowThreads(__tstate);
23089 if (PyErr_Occurred()) SWIG_fail;
23090 }
23091 resultobj = SWIG_From_int(static_cast< int >(result));
23092 return resultobj;
23093 fail:
23094 return NULL;
23095 }
23096
23097
23098 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23099 PyObject *resultobj = 0;
23100 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23101 int result;
23102 void *argp1 = 0 ;
23103 int res1 = 0 ;
23104 PyObject *swig_obj[1] ;
23105
23106 if (!args) SWIG_fail;
23107 swig_obj[0] = args;
23108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23109 if (!SWIG_IsOK(res1)) {
23110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23111 }
23112 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23113 {
23114 PyThreadState* __tstate = wxPyBeginAllowThreads();
23115 result = (int)((wxKeyEvent const *)arg1)->GetY();
23116 wxPyEndAllowThreads(__tstate);
23117 if (PyErr_Occurred()) SWIG_fail;
23118 }
23119 resultobj = SWIG_From_int(static_cast< int >(result));
23120 return resultobj;
23121 fail:
23122 return NULL;
23123 }
23124
23125
23126 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23127 PyObject *resultobj = 0;
23128 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23129 int arg2 ;
23130 void *argp1 = 0 ;
23131 int res1 = 0 ;
23132 int val2 ;
23133 int ecode2 = 0 ;
23134 PyObject *swig_obj[2] ;
23135
23136 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23138 if (!SWIG_IsOK(res1)) {
23139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23140 }
23141 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23142 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23143 if (!SWIG_IsOK(ecode2)) {
23144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23145 }
23146 arg2 = static_cast< int >(val2);
23147 if (arg1) (arg1)->m_x = arg2;
23148
23149 resultobj = SWIG_Py_Void();
23150 return resultobj;
23151 fail:
23152 return NULL;
23153 }
23154
23155
23156 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23157 PyObject *resultobj = 0;
23158 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23159 int result;
23160 void *argp1 = 0 ;
23161 int res1 = 0 ;
23162 PyObject *swig_obj[1] ;
23163
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_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23169 }
23170 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23171 result = (int) ((arg1)->m_x);
23172 resultobj = SWIG_From_int(static_cast< int >(result));
23173 return resultobj;
23174 fail:
23175 return NULL;
23176 }
23177
23178
23179 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23180 PyObject *resultobj = 0;
23181 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23182 int arg2 ;
23183 void *argp1 = 0 ;
23184 int res1 = 0 ;
23185 int val2 ;
23186 int ecode2 = 0 ;
23187 PyObject *swig_obj[2] ;
23188
23189 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
23190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23191 if (!SWIG_IsOK(res1)) {
23192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23193 }
23194 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23195 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23196 if (!SWIG_IsOK(ecode2)) {
23197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
23198 }
23199 arg2 = static_cast< int >(val2);
23200 if (arg1) (arg1)->m_y = arg2;
23201
23202 resultobj = SWIG_Py_Void();
23203 return resultobj;
23204 fail:
23205 return NULL;
23206 }
23207
23208
23209 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23210 PyObject *resultobj = 0;
23211 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23212 int result;
23213 void *argp1 = 0 ;
23214 int res1 = 0 ;
23215 PyObject *swig_obj[1] ;
23216
23217 if (!args) SWIG_fail;
23218 swig_obj[0] = args;
23219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23220 if (!SWIG_IsOK(res1)) {
23221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23222 }
23223 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23224 result = (int) ((arg1)->m_y);
23225 resultobj = SWIG_From_int(static_cast< int >(result));
23226 return resultobj;
23227 fail:
23228 return NULL;
23229 }
23230
23231
23232 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23233 PyObject *resultobj = 0;
23234 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23235 long arg2 ;
23236 void *argp1 = 0 ;
23237 int res1 = 0 ;
23238 long val2 ;
23239 int ecode2 = 0 ;
23240 PyObject *swig_obj[2] ;
23241
23242 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
23243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23244 if (!SWIG_IsOK(res1)) {
23245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23246 }
23247 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23248 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
23249 if (!SWIG_IsOK(ecode2)) {
23250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
23251 }
23252 arg2 = static_cast< long >(val2);
23253 if (arg1) (arg1)->m_keyCode = arg2;
23254
23255 resultobj = SWIG_Py_Void();
23256 return resultobj;
23257 fail:
23258 return NULL;
23259 }
23260
23261
23262 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23263 PyObject *resultobj = 0;
23264 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23265 long result;
23266 void *argp1 = 0 ;
23267 int res1 = 0 ;
23268 PyObject *swig_obj[1] ;
23269
23270 if (!args) SWIG_fail;
23271 swig_obj[0] = args;
23272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23273 if (!SWIG_IsOK(res1)) {
23274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23275 }
23276 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23277 result = (long) ((arg1)->m_keyCode);
23278 resultobj = SWIG_From_long(static_cast< long >(result));
23279 return resultobj;
23280 fail:
23281 return NULL;
23282 }
23283
23284
23285 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23286 PyObject *resultobj = 0;
23287 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23288 bool arg2 ;
23289 void *argp1 = 0 ;
23290 int res1 = 0 ;
23291 bool val2 ;
23292 int ecode2 = 0 ;
23293 PyObject *swig_obj[2] ;
23294
23295 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
23296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23297 if (!SWIG_IsOK(res1)) {
23298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23299 }
23300 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23301 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23302 if (!SWIG_IsOK(ecode2)) {
23303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
23304 }
23305 arg2 = static_cast< bool >(val2);
23306 if (arg1) (arg1)->m_controlDown = arg2;
23307
23308 resultobj = SWIG_Py_Void();
23309 return resultobj;
23310 fail:
23311 return NULL;
23312 }
23313
23314
23315 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23316 PyObject *resultobj = 0;
23317 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23318 bool result;
23319 void *argp1 = 0 ;
23320 int res1 = 0 ;
23321 PyObject *swig_obj[1] ;
23322
23323 if (!args) SWIG_fail;
23324 swig_obj[0] = args;
23325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23326 if (!SWIG_IsOK(res1)) {
23327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23328 }
23329 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23330 result = (bool) ((arg1)->m_controlDown);
23331 {
23332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23333 }
23334 return resultobj;
23335 fail:
23336 return NULL;
23337 }
23338
23339
23340 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23341 PyObject *resultobj = 0;
23342 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23343 bool arg2 ;
23344 void *argp1 = 0 ;
23345 int res1 = 0 ;
23346 bool val2 ;
23347 int ecode2 = 0 ;
23348 PyObject *swig_obj[2] ;
23349
23350 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
23351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23352 if (!SWIG_IsOK(res1)) {
23353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23354 }
23355 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23356 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23357 if (!SWIG_IsOK(ecode2)) {
23358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
23359 }
23360 arg2 = static_cast< bool >(val2);
23361 if (arg1) (arg1)->m_shiftDown = arg2;
23362
23363 resultobj = SWIG_Py_Void();
23364 return resultobj;
23365 fail:
23366 return NULL;
23367 }
23368
23369
23370 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23371 PyObject *resultobj = 0;
23372 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23373 bool result;
23374 void *argp1 = 0 ;
23375 int res1 = 0 ;
23376 PyObject *swig_obj[1] ;
23377
23378 if (!args) SWIG_fail;
23379 swig_obj[0] = args;
23380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23381 if (!SWIG_IsOK(res1)) {
23382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23383 }
23384 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23385 result = (bool) ((arg1)->m_shiftDown);
23386 {
23387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23388 }
23389 return resultobj;
23390 fail:
23391 return NULL;
23392 }
23393
23394
23395 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23396 PyObject *resultobj = 0;
23397 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23398 bool arg2 ;
23399 void *argp1 = 0 ;
23400 int res1 = 0 ;
23401 bool val2 ;
23402 int ecode2 = 0 ;
23403 PyObject *swig_obj[2] ;
23404
23405 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
23406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23407 if (!SWIG_IsOK(res1)) {
23408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23409 }
23410 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23411 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23412 if (!SWIG_IsOK(ecode2)) {
23413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
23414 }
23415 arg2 = static_cast< bool >(val2);
23416 if (arg1) (arg1)->m_altDown = arg2;
23417
23418 resultobj = SWIG_Py_Void();
23419 return resultobj;
23420 fail:
23421 return NULL;
23422 }
23423
23424
23425 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23426 PyObject *resultobj = 0;
23427 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23428 bool result;
23429 void *argp1 = 0 ;
23430 int res1 = 0 ;
23431 PyObject *swig_obj[1] ;
23432
23433 if (!args) SWIG_fail;
23434 swig_obj[0] = args;
23435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23436 if (!SWIG_IsOK(res1)) {
23437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23438 }
23439 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23440 result = (bool) ((arg1)->m_altDown);
23441 {
23442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23443 }
23444 return resultobj;
23445 fail:
23446 return NULL;
23447 }
23448
23449
23450 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23451 PyObject *resultobj = 0;
23452 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23453 bool arg2 ;
23454 void *argp1 = 0 ;
23455 int res1 = 0 ;
23456 bool val2 ;
23457 int ecode2 = 0 ;
23458 PyObject *swig_obj[2] ;
23459
23460 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23462 if (!SWIG_IsOK(res1)) {
23463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23464 }
23465 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23466 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23467 if (!SWIG_IsOK(ecode2)) {
23468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23469 }
23470 arg2 = static_cast< bool >(val2);
23471 if (arg1) (arg1)->m_metaDown = arg2;
23472
23473 resultobj = SWIG_Py_Void();
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23481 PyObject *resultobj = 0;
23482 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23483 bool result;
23484 void *argp1 = 0 ;
23485 int res1 = 0 ;
23486 PyObject *swig_obj[1] ;
23487
23488 if (!args) SWIG_fail;
23489 swig_obj[0] = args;
23490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23491 if (!SWIG_IsOK(res1)) {
23492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23493 }
23494 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23495 result = (bool) ((arg1)->m_metaDown);
23496 {
23497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23498 }
23499 return resultobj;
23500 fail:
23501 return NULL;
23502 }
23503
23504
23505 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23506 PyObject *resultobj = 0;
23507 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23508 bool arg2 ;
23509 void *argp1 = 0 ;
23510 int res1 = 0 ;
23511 bool val2 ;
23512 int ecode2 = 0 ;
23513 PyObject *swig_obj[2] ;
23514
23515 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23517 if (!SWIG_IsOK(res1)) {
23518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23519 }
23520 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23521 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23522 if (!SWIG_IsOK(ecode2)) {
23523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23524 }
23525 arg2 = static_cast< bool >(val2);
23526 if (arg1) (arg1)->m_scanCode = arg2;
23527
23528 resultobj = SWIG_Py_Void();
23529 return resultobj;
23530 fail:
23531 return NULL;
23532 }
23533
23534
23535 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23536 PyObject *resultobj = 0;
23537 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23538 bool result;
23539 void *argp1 = 0 ;
23540 int res1 = 0 ;
23541 PyObject *swig_obj[1] ;
23542
23543 if (!args) SWIG_fail;
23544 swig_obj[0] = args;
23545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23546 if (!SWIG_IsOK(res1)) {
23547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23548 }
23549 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23550 result = (bool) ((arg1)->m_scanCode);
23551 {
23552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23553 }
23554 return resultobj;
23555 fail:
23556 return NULL;
23557 }
23558
23559
23560 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23561 PyObject *resultobj = 0;
23562 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23563 unsigned int arg2 ;
23564 void *argp1 = 0 ;
23565 int res1 = 0 ;
23566 unsigned int val2 ;
23567 int ecode2 = 0 ;
23568 PyObject *swig_obj[2] ;
23569
23570 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23572 if (!SWIG_IsOK(res1)) {
23573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23574 }
23575 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23576 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23577 if (!SWIG_IsOK(ecode2)) {
23578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23579 }
23580 arg2 = static_cast< unsigned int >(val2);
23581 if (arg1) (arg1)->m_rawCode = arg2;
23582
23583 resultobj = SWIG_Py_Void();
23584 return resultobj;
23585 fail:
23586 return NULL;
23587 }
23588
23589
23590 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23591 PyObject *resultobj = 0;
23592 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23593 unsigned int result;
23594 void *argp1 = 0 ;
23595 int res1 = 0 ;
23596 PyObject *swig_obj[1] ;
23597
23598 if (!args) SWIG_fail;
23599 swig_obj[0] = args;
23600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23601 if (!SWIG_IsOK(res1)) {
23602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23603 }
23604 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23605 result = (unsigned int) ((arg1)->m_rawCode);
23606 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23607 return resultobj;
23608 fail:
23609 return NULL;
23610 }
23611
23612
23613 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23614 PyObject *resultobj = 0;
23615 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23616 unsigned int arg2 ;
23617 void *argp1 = 0 ;
23618 int res1 = 0 ;
23619 unsigned int val2 ;
23620 int ecode2 = 0 ;
23621 PyObject *swig_obj[2] ;
23622
23623 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23625 if (!SWIG_IsOK(res1)) {
23626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23627 }
23628 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23629 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23630 if (!SWIG_IsOK(ecode2)) {
23631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23632 }
23633 arg2 = static_cast< unsigned int >(val2);
23634 if (arg1) (arg1)->m_rawFlags = arg2;
23635
23636 resultobj = SWIG_Py_Void();
23637 return resultobj;
23638 fail:
23639 return NULL;
23640 }
23641
23642
23643 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23644 PyObject *resultobj = 0;
23645 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23646 unsigned int result;
23647 void *argp1 = 0 ;
23648 int res1 = 0 ;
23649 PyObject *swig_obj[1] ;
23650
23651 if (!args) SWIG_fail;
23652 swig_obj[0] = args;
23653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23654 if (!SWIG_IsOK(res1)) {
23655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23656 }
23657 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23658 result = (unsigned int) ((arg1)->m_rawFlags);
23659 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23660 return resultobj;
23661 fail:
23662 return NULL;
23663 }
23664
23665
23666 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23667 PyObject *obj;
23668 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23669 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23670 return SWIG_Py_Void();
23671 }
23672
23673 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23674 return SWIG_Python_InitShadowInstance(args);
23675 }
23676
23677 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23678 PyObject *resultobj = 0;
23679 wxSize const &arg1_defvalue = wxDefaultSize ;
23680 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23681 int arg2 = (int) 0 ;
23682 wxSizeEvent *result = 0 ;
23683 wxSize temp1 ;
23684 int val2 ;
23685 int ecode2 = 0 ;
23686 PyObject * obj0 = 0 ;
23687 PyObject * obj1 = 0 ;
23688 char * kwnames[] = {
23689 (char *) "sz",(char *) "winid", NULL
23690 };
23691
23692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23693 if (obj0) {
23694 {
23695 arg1 = &temp1;
23696 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23697 }
23698 }
23699 if (obj1) {
23700 ecode2 = SWIG_AsVal_int(obj1, &val2);
23701 if (!SWIG_IsOK(ecode2)) {
23702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23703 }
23704 arg2 = static_cast< int >(val2);
23705 }
23706 {
23707 PyThreadState* __tstate = wxPyBeginAllowThreads();
23708 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23709 wxPyEndAllowThreads(__tstate);
23710 if (PyErr_Occurred()) SWIG_fail;
23711 }
23712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23713 return resultobj;
23714 fail:
23715 return NULL;
23716 }
23717
23718
23719 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23720 PyObject *resultobj = 0;
23721 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23722 wxSize result;
23723 void *argp1 = 0 ;
23724 int res1 = 0 ;
23725 PyObject *swig_obj[1] ;
23726
23727 if (!args) SWIG_fail;
23728 swig_obj[0] = args;
23729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23730 if (!SWIG_IsOK(res1)) {
23731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23732 }
23733 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23734 {
23735 PyThreadState* __tstate = wxPyBeginAllowThreads();
23736 result = ((wxSizeEvent const *)arg1)->GetSize();
23737 wxPyEndAllowThreads(__tstate);
23738 if (PyErr_Occurred()) SWIG_fail;
23739 }
23740 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23741 return resultobj;
23742 fail:
23743 return NULL;
23744 }
23745
23746
23747 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23748 PyObject *resultobj = 0;
23749 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23750 wxRect result;
23751 void *argp1 = 0 ;
23752 int res1 = 0 ;
23753 PyObject *swig_obj[1] ;
23754
23755 if (!args) SWIG_fail;
23756 swig_obj[0] = args;
23757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23758 if (!SWIG_IsOK(res1)) {
23759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23760 }
23761 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23762 {
23763 PyThreadState* __tstate = wxPyBeginAllowThreads();
23764 result = ((wxSizeEvent const *)arg1)->GetRect();
23765 wxPyEndAllowThreads(__tstate);
23766 if (PyErr_Occurred()) SWIG_fail;
23767 }
23768 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23769 return resultobj;
23770 fail:
23771 return NULL;
23772 }
23773
23774
23775 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23776 PyObject *resultobj = 0;
23777 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23778 wxRect arg2 ;
23779 void *argp1 = 0 ;
23780 int res1 = 0 ;
23781 void *argp2 ;
23782 int res2 = 0 ;
23783 PyObject * obj0 = 0 ;
23784 PyObject * obj1 = 0 ;
23785 char * kwnames[] = {
23786 (char *) "self",(char *) "rect", NULL
23787 };
23788
23789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23791 if (!SWIG_IsOK(res1)) {
23792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23793 }
23794 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23795 {
23796 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23797 if (!SWIG_IsOK(res2)) {
23798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23799 }
23800 if (!argp2) {
23801 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23802 } else {
23803 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23804 arg2 = *temp;
23805 if (SWIG_IsNewObj(res2)) delete temp;
23806 }
23807 }
23808 {
23809 PyThreadState* __tstate = wxPyBeginAllowThreads();
23810 (arg1)->SetRect(arg2);
23811 wxPyEndAllowThreads(__tstate);
23812 if (PyErr_Occurred()) SWIG_fail;
23813 }
23814 resultobj = SWIG_Py_Void();
23815 return resultobj;
23816 fail:
23817 return NULL;
23818 }
23819
23820
23821 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23822 PyObject *resultobj = 0;
23823 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23824 wxSize arg2 ;
23825 void *argp1 = 0 ;
23826 int res1 = 0 ;
23827 void *argp2 ;
23828 int res2 = 0 ;
23829 PyObject * obj0 = 0 ;
23830 PyObject * obj1 = 0 ;
23831 char * kwnames[] = {
23832 (char *) "self",(char *) "size", NULL
23833 };
23834
23835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23837 if (!SWIG_IsOK(res1)) {
23838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23839 }
23840 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23841 {
23842 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23843 if (!SWIG_IsOK(res2)) {
23844 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23845 }
23846 if (!argp2) {
23847 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23848 } else {
23849 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23850 arg2 = *temp;
23851 if (SWIG_IsNewObj(res2)) delete temp;
23852 }
23853 }
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 wxSizeEvent_SetSize(arg1,arg2);
23857 wxPyEndAllowThreads(__tstate);
23858 if (PyErr_Occurred()) SWIG_fail;
23859 }
23860 resultobj = SWIG_Py_Void();
23861 return resultobj;
23862 fail:
23863 return NULL;
23864 }
23865
23866
23867 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23868 PyObject *resultobj = 0;
23869 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23870 wxSize *arg2 = (wxSize *) 0 ;
23871 void *argp1 = 0 ;
23872 int res1 = 0 ;
23873 void *argp2 = 0 ;
23874 int res2 = 0 ;
23875 PyObject *swig_obj[2] ;
23876
23877 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23879 if (!SWIG_IsOK(res1)) {
23880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23881 }
23882 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23883 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23884 if (!SWIG_IsOK(res2)) {
23885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23886 }
23887 arg2 = reinterpret_cast< wxSize * >(argp2);
23888 if (arg1) (arg1)->m_size = *arg2;
23889
23890 resultobj = SWIG_Py_Void();
23891 return resultobj;
23892 fail:
23893 return NULL;
23894 }
23895
23896
23897 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23898 PyObject *resultobj = 0;
23899 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23900 wxSize *result = 0 ;
23901 void *argp1 = 0 ;
23902 int res1 = 0 ;
23903 PyObject *swig_obj[1] ;
23904
23905 if (!args) SWIG_fail;
23906 swig_obj[0] = args;
23907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23908 if (!SWIG_IsOK(res1)) {
23909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23910 }
23911 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23912 result = (wxSize *)& ((arg1)->m_size);
23913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23914 return resultobj;
23915 fail:
23916 return NULL;
23917 }
23918
23919
23920 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23921 PyObject *resultobj = 0;
23922 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23923 wxRect *arg2 = (wxRect *) 0 ;
23924 void *argp1 = 0 ;
23925 int res1 = 0 ;
23926 void *argp2 = 0 ;
23927 int res2 = 0 ;
23928 PyObject *swig_obj[2] ;
23929
23930 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23932 if (!SWIG_IsOK(res1)) {
23933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23934 }
23935 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23936 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23937 if (!SWIG_IsOK(res2)) {
23938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23939 }
23940 arg2 = reinterpret_cast< wxRect * >(argp2);
23941 if (arg1) (arg1)->m_rect = *arg2;
23942
23943 resultobj = SWIG_Py_Void();
23944 return resultobj;
23945 fail:
23946 return NULL;
23947 }
23948
23949
23950 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23951 PyObject *resultobj = 0;
23952 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23953 wxRect *result = 0 ;
23954 void *argp1 = 0 ;
23955 int res1 = 0 ;
23956 PyObject *swig_obj[1] ;
23957
23958 if (!args) SWIG_fail;
23959 swig_obj[0] = args;
23960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23961 if (!SWIG_IsOK(res1)) {
23962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23963 }
23964 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23965 result = (wxRect *)& ((arg1)->m_rect);
23966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23967 return resultobj;
23968 fail:
23969 return NULL;
23970 }
23971
23972
23973 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23974 PyObject *obj;
23975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23976 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23977 return SWIG_Py_Void();
23978 }
23979
23980 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23981 return SWIG_Python_InitShadowInstance(args);
23982 }
23983
23984 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23985 PyObject *resultobj = 0;
23986 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23987 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23988 int arg2 = (int) 0 ;
23989 wxMoveEvent *result = 0 ;
23990 wxPoint temp1 ;
23991 int val2 ;
23992 int ecode2 = 0 ;
23993 PyObject * obj0 = 0 ;
23994 PyObject * obj1 = 0 ;
23995 char * kwnames[] = {
23996 (char *) "pos",(char *) "winid", NULL
23997 };
23998
23999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24000 if (obj0) {
24001 {
24002 arg1 = &temp1;
24003 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
24004 }
24005 }
24006 if (obj1) {
24007 ecode2 = SWIG_AsVal_int(obj1, &val2);
24008 if (!SWIG_IsOK(ecode2)) {
24009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
24010 }
24011 arg2 = static_cast< int >(val2);
24012 }
24013 {
24014 PyThreadState* __tstate = wxPyBeginAllowThreads();
24015 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
24016 wxPyEndAllowThreads(__tstate);
24017 if (PyErr_Occurred()) SWIG_fail;
24018 }
24019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
24020 return resultobj;
24021 fail:
24022 return NULL;
24023 }
24024
24025
24026 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24027 PyObject *resultobj = 0;
24028 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24029 wxPoint result;
24030 void *argp1 = 0 ;
24031 int res1 = 0 ;
24032 PyObject *swig_obj[1] ;
24033
24034 if (!args) SWIG_fail;
24035 swig_obj[0] = args;
24036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24037 if (!SWIG_IsOK(res1)) {
24038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24039 }
24040 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24041 {
24042 PyThreadState* __tstate = wxPyBeginAllowThreads();
24043 result = ((wxMoveEvent const *)arg1)->GetPosition();
24044 wxPyEndAllowThreads(__tstate);
24045 if (PyErr_Occurred()) SWIG_fail;
24046 }
24047 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24048 return resultobj;
24049 fail:
24050 return NULL;
24051 }
24052
24053
24054 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24055 PyObject *resultobj = 0;
24056 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24057 wxRect result;
24058 void *argp1 = 0 ;
24059 int res1 = 0 ;
24060 PyObject *swig_obj[1] ;
24061
24062 if (!args) SWIG_fail;
24063 swig_obj[0] = args;
24064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24065 if (!SWIG_IsOK(res1)) {
24066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24067 }
24068 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24069 {
24070 PyThreadState* __tstate = wxPyBeginAllowThreads();
24071 result = ((wxMoveEvent const *)arg1)->GetRect();
24072 wxPyEndAllowThreads(__tstate);
24073 if (PyErr_Occurred()) SWIG_fail;
24074 }
24075 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
24076 return resultobj;
24077 fail:
24078 return NULL;
24079 }
24080
24081
24082 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24083 PyObject *resultobj = 0;
24084 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24085 wxRect *arg2 = 0 ;
24086 void *argp1 = 0 ;
24087 int res1 = 0 ;
24088 wxRect temp2 ;
24089 PyObject * obj0 = 0 ;
24090 PyObject * obj1 = 0 ;
24091 char * kwnames[] = {
24092 (char *) "self",(char *) "rect", NULL
24093 };
24094
24095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
24096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24097 if (!SWIG_IsOK(res1)) {
24098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24099 }
24100 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24101 {
24102 arg2 = &temp2;
24103 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
24104 }
24105 {
24106 PyThreadState* __tstate = wxPyBeginAllowThreads();
24107 (arg1)->SetRect((wxRect const &)*arg2);
24108 wxPyEndAllowThreads(__tstate);
24109 if (PyErr_Occurred()) SWIG_fail;
24110 }
24111 resultobj = SWIG_Py_Void();
24112 return resultobj;
24113 fail:
24114 return NULL;
24115 }
24116
24117
24118 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24119 PyObject *resultobj = 0;
24120 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24121 wxPoint *arg2 = 0 ;
24122 void *argp1 = 0 ;
24123 int res1 = 0 ;
24124 wxPoint temp2 ;
24125 PyObject * obj0 = 0 ;
24126 PyObject * obj1 = 0 ;
24127 char * kwnames[] = {
24128 (char *) "self",(char *) "pos", NULL
24129 };
24130
24131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24133 if (!SWIG_IsOK(res1)) {
24134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24135 }
24136 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24137 {
24138 arg2 = &temp2;
24139 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
24140 }
24141 {
24142 PyThreadState* __tstate = wxPyBeginAllowThreads();
24143 (arg1)->SetPosition((wxPoint const &)*arg2);
24144 wxPyEndAllowThreads(__tstate);
24145 if (PyErr_Occurred()) SWIG_fail;
24146 }
24147 resultobj = SWIG_Py_Void();
24148 return resultobj;
24149 fail:
24150 return NULL;
24151 }
24152
24153
24154 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24155 PyObject *obj;
24156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24157 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
24158 return SWIG_Py_Void();
24159 }
24160
24161 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24162 return SWIG_Python_InitShadowInstance(args);
24163 }
24164
24165 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24166 PyObject *resultobj = 0;
24167 int arg1 = (int) 0 ;
24168 wxPaintEvent *result = 0 ;
24169 int val1 ;
24170 int ecode1 = 0 ;
24171 PyObject * obj0 = 0 ;
24172 char * kwnames[] = {
24173 (char *) "Id", NULL
24174 };
24175
24176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
24177 if (obj0) {
24178 ecode1 = SWIG_AsVal_int(obj0, &val1);
24179 if (!SWIG_IsOK(ecode1)) {
24180 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
24181 }
24182 arg1 = static_cast< int >(val1);
24183 }
24184 {
24185 PyThreadState* __tstate = wxPyBeginAllowThreads();
24186 result = (wxPaintEvent *)new wxPaintEvent(arg1);
24187 wxPyEndAllowThreads(__tstate);
24188 if (PyErr_Occurred()) SWIG_fail;
24189 }
24190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
24191 return resultobj;
24192 fail:
24193 return NULL;
24194 }
24195
24196
24197 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24198 PyObject *obj;
24199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24200 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
24201 return SWIG_Py_Void();
24202 }
24203
24204 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24205 return SWIG_Python_InitShadowInstance(args);
24206 }
24207
24208 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24209 PyObject *resultobj = 0;
24210 int arg1 = (int) 0 ;
24211 wxNcPaintEvent *result = 0 ;
24212 int val1 ;
24213 int ecode1 = 0 ;
24214 PyObject * obj0 = 0 ;
24215 char * kwnames[] = {
24216 (char *) "winid", NULL
24217 };
24218
24219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
24220 if (obj0) {
24221 ecode1 = SWIG_AsVal_int(obj0, &val1);
24222 if (!SWIG_IsOK(ecode1)) {
24223 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
24224 }
24225 arg1 = static_cast< int >(val1);
24226 }
24227 {
24228 PyThreadState* __tstate = wxPyBeginAllowThreads();
24229 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
24230 wxPyEndAllowThreads(__tstate);
24231 if (PyErr_Occurred()) SWIG_fail;
24232 }
24233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
24234 return resultobj;
24235 fail:
24236 return NULL;
24237 }
24238
24239
24240 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24241 PyObject *obj;
24242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24243 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
24244 return SWIG_Py_Void();
24245 }
24246
24247 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24248 return SWIG_Python_InitShadowInstance(args);
24249 }
24250
24251 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24252 PyObject *resultobj = 0;
24253 int arg1 = (int) 0 ;
24254 wxDC *arg2 = (wxDC *) NULL ;
24255 wxEraseEvent *result = 0 ;
24256 int val1 ;
24257 int ecode1 = 0 ;
24258 void *argp2 = 0 ;
24259 int res2 = 0 ;
24260 PyObject * obj0 = 0 ;
24261 PyObject * obj1 = 0 ;
24262 char * kwnames[] = {
24263 (char *) "Id",(char *) "dc", NULL
24264 };
24265
24266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24267 if (obj0) {
24268 ecode1 = SWIG_AsVal_int(obj0, &val1);
24269 if (!SWIG_IsOK(ecode1)) {
24270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
24271 }
24272 arg1 = static_cast< int >(val1);
24273 }
24274 if (obj1) {
24275 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
24276 if (!SWIG_IsOK(res2)) {
24277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
24278 }
24279 arg2 = reinterpret_cast< wxDC * >(argp2);
24280 }
24281 {
24282 PyThreadState* __tstate = wxPyBeginAllowThreads();
24283 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
24284 wxPyEndAllowThreads(__tstate);
24285 if (PyErr_Occurred()) SWIG_fail;
24286 }
24287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
24288 return resultobj;
24289 fail:
24290 return NULL;
24291 }
24292
24293
24294 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24295 PyObject *resultobj = 0;
24296 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
24297 wxDC *result = 0 ;
24298 void *argp1 = 0 ;
24299 int res1 = 0 ;
24300 PyObject *swig_obj[1] ;
24301
24302 if (!args) SWIG_fail;
24303 swig_obj[0] = args;
24304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
24305 if (!SWIG_IsOK(res1)) {
24306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
24307 }
24308 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
24309 {
24310 PyThreadState* __tstate = wxPyBeginAllowThreads();
24311 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
24312 wxPyEndAllowThreads(__tstate);
24313 if (PyErr_Occurred()) SWIG_fail;
24314 }
24315 {
24316 resultobj = wxPyMake_wxObject(result, (bool)0);
24317 }
24318 return resultobj;
24319 fail:
24320 return NULL;
24321 }
24322
24323
24324 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24325 PyObject *obj;
24326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24327 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
24328 return SWIG_Py_Void();
24329 }
24330
24331 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24332 return SWIG_Python_InitShadowInstance(args);
24333 }
24334
24335 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24336 PyObject *resultobj = 0;
24337 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24338 int arg2 = (int) 0 ;
24339 wxFocusEvent *result = 0 ;
24340 int val1 ;
24341 int ecode1 = 0 ;
24342 int val2 ;
24343 int ecode2 = 0 ;
24344 PyObject * obj0 = 0 ;
24345 PyObject * obj1 = 0 ;
24346 char * kwnames[] = {
24347 (char *) "type",(char *) "winid", NULL
24348 };
24349
24350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24351 if (obj0) {
24352 ecode1 = SWIG_AsVal_int(obj0, &val1);
24353 if (!SWIG_IsOK(ecode1)) {
24354 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24355 }
24356 arg1 = static_cast< wxEventType >(val1);
24357 }
24358 if (obj1) {
24359 ecode2 = SWIG_AsVal_int(obj1, &val2);
24360 if (!SWIG_IsOK(ecode2)) {
24361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
24362 }
24363 arg2 = static_cast< int >(val2);
24364 }
24365 {
24366 PyThreadState* __tstate = wxPyBeginAllowThreads();
24367 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
24368 wxPyEndAllowThreads(__tstate);
24369 if (PyErr_Occurred()) SWIG_fail;
24370 }
24371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
24372 return resultobj;
24373 fail:
24374 return NULL;
24375 }
24376
24377
24378 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24379 PyObject *resultobj = 0;
24380 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24381 wxWindow *result = 0 ;
24382 void *argp1 = 0 ;
24383 int res1 = 0 ;
24384 PyObject *swig_obj[1] ;
24385
24386 if (!args) SWIG_fail;
24387 swig_obj[0] = args;
24388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24389 if (!SWIG_IsOK(res1)) {
24390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
24391 }
24392 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24393 {
24394 PyThreadState* __tstate = wxPyBeginAllowThreads();
24395 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
24396 wxPyEndAllowThreads(__tstate);
24397 if (PyErr_Occurred()) SWIG_fail;
24398 }
24399 {
24400 resultobj = wxPyMake_wxObject(result, (bool)0);
24401 }
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24409 PyObject *resultobj = 0;
24410 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24411 wxWindow *arg2 = (wxWindow *) 0 ;
24412 void *argp1 = 0 ;
24413 int res1 = 0 ;
24414 void *argp2 = 0 ;
24415 int res2 = 0 ;
24416 PyObject * obj0 = 0 ;
24417 PyObject * obj1 = 0 ;
24418 char * kwnames[] = {
24419 (char *) "self",(char *) "win", NULL
24420 };
24421
24422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
24423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24424 if (!SWIG_IsOK(res1)) {
24425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
24426 }
24427 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24428 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24429 if (!SWIG_IsOK(res2)) {
24430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
24431 }
24432 arg2 = reinterpret_cast< wxWindow * >(argp2);
24433 {
24434 PyThreadState* __tstate = wxPyBeginAllowThreads();
24435 (arg1)->SetWindow(arg2);
24436 wxPyEndAllowThreads(__tstate);
24437 if (PyErr_Occurred()) SWIG_fail;
24438 }
24439 resultobj = SWIG_Py_Void();
24440 return resultobj;
24441 fail:
24442 return NULL;
24443 }
24444
24445
24446 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24447 PyObject *obj;
24448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24449 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24450 return SWIG_Py_Void();
24451 }
24452
24453 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24454 return SWIG_Python_InitShadowInstance(args);
24455 }
24456
24457 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24458 PyObject *resultobj = 0;
24459 wxWindow *arg1 = (wxWindow *) NULL ;
24460 wxChildFocusEvent *result = 0 ;
24461 void *argp1 = 0 ;
24462 int res1 = 0 ;
24463 PyObject * obj0 = 0 ;
24464 char * kwnames[] = {
24465 (char *) "win", NULL
24466 };
24467
24468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24469 if (obj0) {
24470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24471 if (!SWIG_IsOK(res1)) {
24472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24473 }
24474 arg1 = reinterpret_cast< wxWindow * >(argp1);
24475 }
24476 {
24477 PyThreadState* __tstate = wxPyBeginAllowThreads();
24478 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24479 wxPyEndAllowThreads(__tstate);
24480 if (PyErr_Occurred()) SWIG_fail;
24481 }
24482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24483 return resultobj;
24484 fail:
24485 return NULL;
24486 }
24487
24488
24489 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24490 PyObject *resultobj = 0;
24491 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24492 wxWindow *result = 0 ;
24493 void *argp1 = 0 ;
24494 int res1 = 0 ;
24495 PyObject *swig_obj[1] ;
24496
24497 if (!args) SWIG_fail;
24498 swig_obj[0] = args;
24499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24500 if (!SWIG_IsOK(res1)) {
24501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24502 }
24503 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24504 {
24505 PyThreadState* __tstate = wxPyBeginAllowThreads();
24506 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24507 wxPyEndAllowThreads(__tstate);
24508 if (PyErr_Occurred()) SWIG_fail;
24509 }
24510 {
24511 resultobj = wxPyMake_wxObject(result, (bool)0);
24512 }
24513 return resultobj;
24514 fail:
24515 return NULL;
24516 }
24517
24518
24519 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24520 PyObject *obj;
24521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24522 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24523 return SWIG_Py_Void();
24524 }
24525
24526 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24527 return SWIG_Python_InitShadowInstance(args);
24528 }
24529
24530 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24531 PyObject *resultobj = 0;
24532 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24533 bool arg2 = (bool) true ;
24534 int arg3 = (int) 0 ;
24535 wxActivateEvent *result = 0 ;
24536 int val1 ;
24537 int ecode1 = 0 ;
24538 bool val2 ;
24539 int ecode2 = 0 ;
24540 int val3 ;
24541 int ecode3 = 0 ;
24542 PyObject * obj0 = 0 ;
24543 PyObject * obj1 = 0 ;
24544 PyObject * obj2 = 0 ;
24545 char * kwnames[] = {
24546 (char *) "type",(char *) "active",(char *) "Id", NULL
24547 };
24548
24549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24550 if (obj0) {
24551 ecode1 = SWIG_AsVal_int(obj0, &val1);
24552 if (!SWIG_IsOK(ecode1)) {
24553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24554 }
24555 arg1 = static_cast< wxEventType >(val1);
24556 }
24557 if (obj1) {
24558 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24559 if (!SWIG_IsOK(ecode2)) {
24560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24561 }
24562 arg2 = static_cast< bool >(val2);
24563 }
24564 if (obj2) {
24565 ecode3 = SWIG_AsVal_int(obj2, &val3);
24566 if (!SWIG_IsOK(ecode3)) {
24567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24568 }
24569 arg3 = static_cast< int >(val3);
24570 }
24571 {
24572 PyThreadState* __tstate = wxPyBeginAllowThreads();
24573 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24574 wxPyEndAllowThreads(__tstate);
24575 if (PyErr_Occurred()) SWIG_fail;
24576 }
24577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24578 return resultobj;
24579 fail:
24580 return NULL;
24581 }
24582
24583
24584 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24585 PyObject *resultobj = 0;
24586 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24587 bool result;
24588 void *argp1 = 0 ;
24589 int res1 = 0 ;
24590 PyObject *swig_obj[1] ;
24591
24592 if (!args) SWIG_fail;
24593 swig_obj[0] = args;
24594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24595 if (!SWIG_IsOK(res1)) {
24596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24597 }
24598 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24599 {
24600 PyThreadState* __tstate = wxPyBeginAllowThreads();
24601 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24602 wxPyEndAllowThreads(__tstate);
24603 if (PyErr_Occurred()) SWIG_fail;
24604 }
24605 {
24606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24607 }
24608 return resultobj;
24609 fail:
24610 return NULL;
24611 }
24612
24613
24614 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24615 PyObject *obj;
24616 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24617 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24618 return SWIG_Py_Void();
24619 }
24620
24621 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24622 return SWIG_Python_InitShadowInstance(args);
24623 }
24624
24625 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24626 PyObject *resultobj = 0;
24627 int arg1 = (int) 0 ;
24628 wxInitDialogEvent *result = 0 ;
24629 int val1 ;
24630 int ecode1 = 0 ;
24631 PyObject * obj0 = 0 ;
24632 char * kwnames[] = {
24633 (char *) "Id", NULL
24634 };
24635
24636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24637 if (obj0) {
24638 ecode1 = SWIG_AsVal_int(obj0, &val1);
24639 if (!SWIG_IsOK(ecode1)) {
24640 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24641 }
24642 arg1 = static_cast< int >(val1);
24643 }
24644 {
24645 PyThreadState* __tstate = wxPyBeginAllowThreads();
24646 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24647 wxPyEndAllowThreads(__tstate);
24648 if (PyErr_Occurred()) SWIG_fail;
24649 }
24650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24651 return resultobj;
24652 fail:
24653 return NULL;
24654 }
24655
24656
24657 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24658 PyObject *obj;
24659 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24660 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24661 return SWIG_Py_Void();
24662 }
24663
24664 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24665 return SWIG_Python_InitShadowInstance(args);
24666 }
24667
24668 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24669 PyObject *resultobj = 0;
24670 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24671 int arg2 = (int) 0 ;
24672 wxMenu *arg3 = (wxMenu *) NULL ;
24673 wxMenuEvent *result = 0 ;
24674 int val1 ;
24675 int ecode1 = 0 ;
24676 int val2 ;
24677 int ecode2 = 0 ;
24678 void *argp3 = 0 ;
24679 int res3 = 0 ;
24680 PyObject * obj0 = 0 ;
24681 PyObject * obj1 = 0 ;
24682 PyObject * obj2 = 0 ;
24683 char * kwnames[] = {
24684 (char *) "type",(char *) "winid",(char *) "menu", NULL
24685 };
24686
24687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24688 if (obj0) {
24689 ecode1 = SWIG_AsVal_int(obj0, &val1);
24690 if (!SWIG_IsOK(ecode1)) {
24691 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24692 }
24693 arg1 = static_cast< wxEventType >(val1);
24694 }
24695 if (obj1) {
24696 ecode2 = SWIG_AsVal_int(obj1, &val2);
24697 if (!SWIG_IsOK(ecode2)) {
24698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24699 }
24700 arg2 = static_cast< int >(val2);
24701 }
24702 if (obj2) {
24703 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24704 if (!SWIG_IsOK(res3)) {
24705 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24706 }
24707 arg3 = reinterpret_cast< wxMenu * >(argp3);
24708 }
24709 {
24710 PyThreadState* __tstate = wxPyBeginAllowThreads();
24711 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24712 wxPyEndAllowThreads(__tstate);
24713 if (PyErr_Occurred()) SWIG_fail;
24714 }
24715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24716 return resultobj;
24717 fail:
24718 return NULL;
24719 }
24720
24721
24722 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24723 PyObject *resultobj = 0;
24724 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24725 int result;
24726 void *argp1 = 0 ;
24727 int res1 = 0 ;
24728 PyObject *swig_obj[1] ;
24729
24730 if (!args) SWIG_fail;
24731 swig_obj[0] = args;
24732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24733 if (!SWIG_IsOK(res1)) {
24734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24735 }
24736 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24737 {
24738 PyThreadState* __tstate = wxPyBeginAllowThreads();
24739 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24740 wxPyEndAllowThreads(__tstate);
24741 if (PyErr_Occurred()) SWIG_fail;
24742 }
24743 resultobj = SWIG_From_int(static_cast< int >(result));
24744 return resultobj;
24745 fail:
24746 return NULL;
24747 }
24748
24749
24750 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24751 PyObject *resultobj = 0;
24752 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24753 bool result;
24754 void *argp1 = 0 ;
24755 int res1 = 0 ;
24756 PyObject *swig_obj[1] ;
24757
24758 if (!args) SWIG_fail;
24759 swig_obj[0] = args;
24760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24761 if (!SWIG_IsOK(res1)) {
24762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24763 }
24764 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24765 {
24766 PyThreadState* __tstate = wxPyBeginAllowThreads();
24767 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24768 wxPyEndAllowThreads(__tstate);
24769 if (PyErr_Occurred()) SWIG_fail;
24770 }
24771 {
24772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24773 }
24774 return resultobj;
24775 fail:
24776 return NULL;
24777 }
24778
24779
24780 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24781 PyObject *resultobj = 0;
24782 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24783 wxMenu *result = 0 ;
24784 void *argp1 = 0 ;
24785 int res1 = 0 ;
24786 PyObject *swig_obj[1] ;
24787
24788 if (!args) SWIG_fail;
24789 swig_obj[0] = args;
24790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24791 if (!SWIG_IsOK(res1)) {
24792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24793 }
24794 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24795 {
24796 PyThreadState* __tstate = wxPyBeginAllowThreads();
24797 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24798 wxPyEndAllowThreads(__tstate);
24799 if (PyErr_Occurred()) SWIG_fail;
24800 }
24801 {
24802 resultobj = wxPyMake_wxObject(result, (bool)0);
24803 }
24804 return resultobj;
24805 fail:
24806 return NULL;
24807 }
24808
24809
24810 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24811 PyObject *obj;
24812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24813 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24814 return SWIG_Py_Void();
24815 }
24816
24817 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24818 return SWIG_Python_InitShadowInstance(args);
24819 }
24820
24821 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24822 PyObject *resultobj = 0;
24823 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24824 int arg2 = (int) 0 ;
24825 wxCloseEvent *result = 0 ;
24826 int val1 ;
24827 int ecode1 = 0 ;
24828 int val2 ;
24829 int ecode2 = 0 ;
24830 PyObject * obj0 = 0 ;
24831 PyObject * obj1 = 0 ;
24832 char * kwnames[] = {
24833 (char *) "type",(char *) "winid", NULL
24834 };
24835
24836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24837 if (obj0) {
24838 ecode1 = SWIG_AsVal_int(obj0, &val1);
24839 if (!SWIG_IsOK(ecode1)) {
24840 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24841 }
24842 arg1 = static_cast< wxEventType >(val1);
24843 }
24844 if (obj1) {
24845 ecode2 = SWIG_AsVal_int(obj1, &val2);
24846 if (!SWIG_IsOK(ecode2)) {
24847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24848 }
24849 arg2 = static_cast< int >(val2);
24850 }
24851 {
24852 PyThreadState* __tstate = wxPyBeginAllowThreads();
24853 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24854 wxPyEndAllowThreads(__tstate);
24855 if (PyErr_Occurred()) SWIG_fail;
24856 }
24857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24858 return resultobj;
24859 fail:
24860 return NULL;
24861 }
24862
24863
24864 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24865 PyObject *resultobj = 0;
24866 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24867 bool arg2 ;
24868 void *argp1 = 0 ;
24869 int res1 = 0 ;
24870 bool val2 ;
24871 int ecode2 = 0 ;
24872 PyObject * obj0 = 0 ;
24873 PyObject * obj1 = 0 ;
24874 char * kwnames[] = {
24875 (char *) "self",(char *) "logOff", NULL
24876 };
24877
24878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24880 if (!SWIG_IsOK(res1)) {
24881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24882 }
24883 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24884 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24885 if (!SWIG_IsOK(ecode2)) {
24886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24887 }
24888 arg2 = static_cast< bool >(val2);
24889 {
24890 PyThreadState* __tstate = wxPyBeginAllowThreads();
24891 (arg1)->SetLoggingOff(arg2);
24892 wxPyEndAllowThreads(__tstate);
24893 if (PyErr_Occurred()) SWIG_fail;
24894 }
24895 resultobj = SWIG_Py_Void();
24896 return resultobj;
24897 fail:
24898 return NULL;
24899 }
24900
24901
24902 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24903 PyObject *resultobj = 0;
24904 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24905 bool result;
24906 void *argp1 = 0 ;
24907 int res1 = 0 ;
24908 PyObject *swig_obj[1] ;
24909
24910 if (!args) SWIG_fail;
24911 swig_obj[0] = args;
24912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24913 if (!SWIG_IsOK(res1)) {
24914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24915 }
24916 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24917 {
24918 PyThreadState* __tstate = wxPyBeginAllowThreads();
24919 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24920 wxPyEndAllowThreads(__tstate);
24921 if (PyErr_Occurred()) SWIG_fail;
24922 }
24923 {
24924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24925 }
24926 return resultobj;
24927 fail:
24928 return NULL;
24929 }
24930
24931
24932 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24933 PyObject *resultobj = 0;
24934 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24935 bool arg2 = (bool) true ;
24936 void *argp1 = 0 ;
24937 int res1 = 0 ;
24938 bool val2 ;
24939 int ecode2 = 0 ;
24940 PyObject * obj0 = 0 ;
24941 PyObject * obj1 = 0 ;
24942 char * kwnames[] = {
24943 (char *) "self",(char *) "veto", NULL
24944 };
24945
24946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24948 if (!SWIG_IsOK(res1)) {
24949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24950 }
24951 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24952 if (obj1) {
24953 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24954 if (!SWIG_IsOK(ecode2)) {
24955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24956 }
24957 arg2 = static_cast< bool >(val2);
24958 }
24959 {
24960 PyThreadState* __tstate = wxPyBeginAllowThreads();
24961 (arg1)->Veto(arg2);
24962 wxPyEndAllowThreads(__tstate);
24963 if (PyErr_Occurred()) SWIG_fail;
24964 }
24965 resultobj = SWIG_Py_Void();
24966 return resultobj;
24967 fail:
24968 return NULL;
24969 }
24970
24971
24972 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24973 PyObject *resultobj = 0;
24974 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24975 bool result;
24976 void *argp1 = 0 ;
24977 int res1 = 0 ;
24978 PyObject *swig_obj[1] ;
24979
24980 if (!args) SWIG_fail;
24981 swig_obj[0] = args;
24982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24983 if (!SWIG_IsOK(res1)) {
24984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24985 }
24986 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24987 {
24988 PyThreadState* __tstate = wxPyBeginAllowThreads();
24989 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24990 wxPyEndAllowThreads(__tstate);
24991 if (PyErr_Occurred()) SWIG_fail;
24992 }
24993 {
24994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24995 }
24996 return resultobj;
24997 fail:
24998 return NULL;
24999 }
25000
25001
25002 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25003 PyObject *resultobj = 0;
25004 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25005 bool arg2 ;
25006 void *argp1 = 0 ;
25007 int res1 = 0 ;
25008 bool val2 ;
25009 int ecode2 = 0 ;
25010 PyObject * obj0 = 0 ;
25011 PyObject * obj1 = 0 ;
25012 char * kwnames[] = {
25013 (char *) "self",(char *) "canVeto", NULL
25014 };
25015
25016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
25017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25018 if (!SWIG_IsOK(res1)) {
25019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25020 }
25021 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25022 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25023 if (!SWIG_IsOK(ecode2)) {
25024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
25025 }
25026 arg2 = static_cast< bool >(val2);
25027 {
25028 PyThreadState* __tstate = wxPyBeginAllowThreads();
25029 (arg1)->SetCanVeto(arg2);
25030 wxPyEndAllowThreads(__tstate);
25031 if (PyErr_Occurred()) SWIG_fail;
25032 }
25033 resultobj = SWIG_Py_Void();
25034 return resultobj;
25035 fail:
25036 return NULL;
25037 }
25038
25039
25040 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25041 PyObject *resultobj = 0;
25042 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25043 bool result;
25044 void *argp1 = 0 ;
25045 int res1 = 0 ;
25046 PyObject *swig_obj[1] ;
25047
25048 if (!args) SWIG_fail;
25049 swig_obj[0] = args;
25050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25051 if (!SWIG_IsOK(res1)) {
25052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25053 }
25054 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25055 {
25056 PyThreadState* __tstate = wxPyBeginAllowThreads();
25057 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
25058 wxPyEndAllowThreads(__tstate);
25059 if (PyErr_Occurred()) SWIG_fail;
25060 }
25061 {
25062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25063 }
25064 return resultobj;
25065 fail:
25066 return NULL;
25067 }
25068
25069
25070 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25071 PyObject *obj;
25072 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25073 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
25074 return SWIG_Py_Void();
25075 }
25076
25077 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25078 return SWIG_Python_InitShadowInstance(args);
25079 }
25080
25081 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25082 PyObject *resultobj = 0;
25083 int arg1 = (int) 0 ;
25084 bool arg2 = (bool) false ;
25085 wxShowEvent *result = 0 ;
25086 int val1 ;
25087 int ecode1 = 0 ;
25088 bool val2 ;
25089 int ecode2 = 0 ;
25090 PyObject * obj0 = 0 ;
25091 PyObject * obj1 = 0 ;
25092 char * kwnames[] = {
25093 (char *) "winid",(char *) "show", NULL
25094 };
25095
25096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25097 if (obj0) {
25098 ecode1 = SWIG_AsVal_int(obj0, &val1);
25099 if (!SWIG_IsOK(ecode1)) {
25100 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
25101 }
25102 arg1 = static_cast< int >(val1);
25103 }
25104 if (obj1) {
25105 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25106 if (!SWIG_IsOK(ecode2)) {
25107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
25108 }
25109 arg2 = static_cast< bool >(val2);
25110 }
25111 {
25112 PyThreadState* __tstate = wxPyBeginAllowThreads();
25113 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
25114 wxPyEndAllowThreads(__tstate);
25115 if (PyErr_Occurred()) SWIG_fail;
25116 }
25117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
25118 return resultobj;
25119 fail:
25120 return NULL;
25121 }
25122
25123
25124 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25125 PyObject *resultobj = 0;
25126 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25127 bool arg2 ;
25128 void *argp1 = 0 ;
25129 int res1 = 0 ;
25130 bool val2 ;
25131 int ecode2 = 0 ;
25132 PyObject * obj0 = 0 ;
25133 PyObject * obj1 = 0 ;
25134 char * kwnames[] = {
25135 (char *) "self",(char *) "show", NULL
25136 };
25137
25138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
25139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25140 if (!SWIG_IsOK(res1)) {
25141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
25142 }
25143 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25144 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25145 if (!SWIG_IsOK(ecode2)) {
25146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
25147 }
25148 arg2 = static_cast< bool >(val2);
25149 {
25150 PyThreadState* __tstate = wxPyBeginAllowThreads();
25151 (arg1)->SetShow(arg2);
25152 wxPyEndAllowThreads(__tstate);
25153 if (PyErr_Occurred()) SWIG_fail;
25154 }
25155 resultobj = SWIG_Py_Void();
25156 return resultobj;
25157 fail:
25158 return NULL;
25159 }
25160
25161
25162 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25163 PyObject *resultobj = 0;
25164 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25165 bool result;
25166 void *argp1 = 0 ;
25167 int res1 = 0 ;
25168 PyObject *swig_obj[1] ;
25169
25170 if (!args) SWIG_fail;
25171 swig_obj[0] = args;
25172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25173 if (!SWIG_IsOK(res1)) {
25174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
25175 }
25176 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25177 {
25178 PyThreadState* __tstate = wxPyBeginAllowThreads();
25179 result = (bool)((wxShowEvent const *)arg1)->GetShow();
25180 wxPyEndAllowThreads(__tstate);
25181 if (PyErr_Occurred()) SWIG_fail;
25182 }
25183 {
25184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25185 }
25186 return resultobj;
25187 fail:
25188 return NULL;
25189 }
25190
25191
25192 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25193 PyObject *obj;
25194 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25195 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
25196 return SWIG_Py_Void();
25197 }
25198
25199 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25200 return SWIG_Python_InitShadowInstance(args);
25201 }
25202
25203 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25204 PyObject *resultobj = 0;
25205 int arg1 = (int) 0 ;
25206 bool arg2 = (bool) true ;
25207 wxIconizeEvent *result = 0 ;
25208 int val1 ;
25209 int ecode1 = 0 ;
25210 bool val2 ;
25211 int ecode2 = 0 ;
25212 PyObject * obj0 = 0 ;
25213 PyObject * obj1 = 0 ;
25214 char * kwnames[] = {
25215 (char *) "id",(char *) "iconized", NULL
25216 };
25217
25218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25219 if (obj0) {
25220 ecode1 = SWIG_AsVal_int(obj0, &val1);
25221 if (!SWIG_IsOK(ecode1)) {
25222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
25223 }
25224 arg1 = static_cast< int >(val1);
25225 }
25226 if (obj1) {
25227 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25228 if (!SWIG_IsOK(ecode2)) {
25229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
25230 }
25231 arg2 = static_cast< bool >(val2);
25232 }
25233 {
25234 PyThreadState* __tstate = wxPyBeginAllowThreads();
25235 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
25236 wxPyEndAllowThreads(__tstate);
25237 if (PyErr_Occurred()) SWIG_fail;
25238 }
25239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
25240 return resultobj;
25241 fail:
25242 return NULL;
25243 }
25244
25245
25246 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25247 PyObject *resultobj = 0;
25248 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
25249 bool result;
25250 void *argp1 = 0 ;
25251 int res1 = 0 ;
25252 PyObject *swig_obj[1] ;
25253
25254 if (!args) SWIG_fail;
25255 swig_obj[0] = args;
25256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
25257 if (!SWIG_IsOK(res1)) {
25258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
25259 }
25260 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
25261 {
25262 PyThreadState* __tstate = wxPyBeginAllowThreads();
25263 result = (bool)(arg1)->Iconized();
25264 wxPyEndAllowThreads(__tstate);
25265 if (PyErr_Occurred()) SWIG_fail;
25266 }
25267 {
25268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25269 }
25270 return resultobj;
25271 fail:
25272 return NULL;
25273 }
25274
25275
25276 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25277 PyObject *obj;
25278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25279 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
25280 return SWIG_Py_Void();
25281 }
25282
25283 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25284 return SWIG_Python_InitShadowInstance(args);
25285 }
25286
25287 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25288 PyObject *resultobj = 0;
25289 int arg1 = (int) 0 ;
25290 wxMaximizeEvent *result = 0 ;
25291 int val1 ;
25292 int ecode1 = 0 ;
25293 PyObject * obj0 = 0 ;
25294 char * kwnames[] = {
25295 (char *) "id", NULL
25296 };
25297
25298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
25299 if (obj0) {
25300 ecode1 = SWIG_AsVal_int(obj0, &val1);
25301 if (!SWIG_IsOK(ecode1)) {
25302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
25303 }
25304 arg1 = static_cast< int >(val1);
25305 }
25306 {
25307 PyThreadState* __tstate = wxPyBeginAllowThreads();
25308 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
25309 wxPyEndAllowThreads(__tstate);
25310 if (PyErr_Occurred()) SWIG_fail;
25311 }
25312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
25313 return resultobj;
25314 fail:
25315 return NULL;
25316 }
25317
25318
25319 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25320 PyObject *obj;
25321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25322 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
25323 return SWIG_Py_Void();
25324 }
25325
25326 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25327 return SWIG_Python_InitShadowInstance(args);
25328 }
25329
25330 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25331 PyObject *resultobj = 0;
25332 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25333 wxPoint result;
25334 void *argp1 = 0 ;
25335 int res1 = 0 ;
25336 PyObject *swig_obj[1] ;
25337
25338 if (!args) SWIG_fail;
25339 swig_obj[0] = args;
25340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25341 if (!SWIG_IsOK(res1)) {
25342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25343 }
25344 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25345 {
25346 PyThreadState* __tstate = wxPyBeginAllowThreads();
25347 result = (arg1)->GetPosition();
25348 wxPyEndAllowThreads(__tstate);
25349 if (PyErr_Occurred()) SWIG_fail;
25350 }
25351 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25352 return resultobj;
25353 fail:
25354 return NULL;
25355 }
25356
25357
25358 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25359 PyObject *resultobj = 0;
25360 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25361 int result;
25362 void *argp1 = 0 ;
25363 int res1 = 0 ;
25364 PyObject *swig_obj[1] ;
25365
25366 if (!args) SWIG_fail;
25367 swig_obj[0] = args;
25368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25369 if (!SWIG_IsOK(res1)) {
25370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25371 }
25372 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25373 {
25374 PyThreadState* __tstate = wxPyBeginAllowThreads();
25375 result = (int)(arg1)->GetNumberOfFiles();
25376 wxPyEndAllowThreads(__tstate);
25377 if (PyErr_Occurred()) SWIG_fail;
25378 }
25379 resultobj = SWIG_From_int(static_cast< int >(result));
25380 return resultobj;
25381 fail:
25382 return NULL;
25383 }
25384
25385
25386 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25387 PyObject *resultobj = 0;
25388 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25389 PyObject *result = 0 ;
25390 void *argp1 = 0 ;
25391 int res1 = 0 ;
25392 PyObject *swig_obj[1] ;
25393
25394 if (!args) SWIG_fail;
25395 swig_obj[0] = args;
25396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25397 if (!SWIG_IsOK(res1)) {
25398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25399 }
25400 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25401 {
25402 PyThreadState* __tstate = wxPyBeginAllowThreads();
25403 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
25404 wxPyEndAllowThreads(__tstate);
25405 if (PyErr_Occurred()) SWIG_fail;
25406 }
25407 resultobj = result;
25408 return resultobj;
25409 fail:
25410 return NULL;
25411 }
25412
25413
25414 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25415 PyObject *obj;
25416 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25417 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
25418 return SWIG_Py_Void();
25419 }
25420
25421 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25422 PyObject *resultobj = 0;
25423 int arg1 = (int) 0 ;
25424 wxUpdateUIEvent *result = 0 ;
25425 int val1 ;
25426 int ecode1 = 0 ;
25427 PyObject * obj0 = 0 ;
25428 char * kwnames[] = {
25429 (char *) "commandId", NULL
25430 };
25431
25432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
25433 if (obj0) {
25434 ecode1 = SWIG_AsVal_int(obj0, &val1);
25435 if (!SWIG_IsOK(ecode1)) {
25436 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
25437 }
25438 arg1 = static_cast< int >(val1);
25439 }
25440 {
25441 PyThreadState* __tstate = wxPyBeginAllowThreads();
25442 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25443 wxPyEndAllowThreads(__tstate);
25444 if (PyErr_Occurred()) SWIG_fail;
25445 }
25446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25447 return resultobj;
25448 fail:
25449 return NULL;
25450 }
25451
25452
25453 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25454 PyObject *resultobj = 0;
25455 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25456 bool result;
25457 void *argp1 = 0 ;
25458 int res1 = 0 ;
25459 PyObject *swig_obj[1] ;
25460
25461 if (!args) SWIG_fail;
25462 swig_obj[0] = args;
25463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25464 if (!SWIG_IsOK(res1)) {
25465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25466 }
25467 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25468 {
25469 PyThreadState* __tstate = wxPyBeginAllowThreads();
25470 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25471 wxPyEndAllowThreads(__tstate);
25472 if (PyErr_Occurred()) SWIG_fail;
25473 }
25474 {
25475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25476 }
25477 return resultobj;
25478 fail:
25479 return NULL;
25480 }
25481
25482
25483 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25484 PyObject *resultobj = 0;
25485 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25486 bool result;
25487 void *argp1 = 0 ;
25488 int res1 = 0 ;
25489 PyObject *swig_obj[1] ;
25490
25491 if (!args) SWIG_fail;
25492 swig_obj[0] = args;
25493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25494 if (!SWIG_IsOK(res1)) {
25495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25496 }
25497 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25498 {
25499 PyThreadState* __tstate = wxPyBeginAllowThreads();
25500 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25501 wxPyEndAllowThreads(__tstate);
25502 if (PyErr_Occurred()) SWIG_fail;
25503 }
25504 {
25505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25506 }
25507 return resultobj;
25508 fail:
25509 return NULL;
25510 }
25511
25512
25513 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25514 PyObject *resultobj = 0;
25515 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25516 bool result;
25517 void *argp1 = 0 ;
25518 int res1 = 0 ;
25519 PyObject *swig_obj[1] ;
25520
25521 if (!args) SWIG_fail;
25522 swig_obj[0] = args;
25523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25524 if (!SWIG_IsOK(res1)) {
25525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25526 }
25527 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25528 {
25529 PyThreadState* __tstate = wxPyBeginAllowThreads();
25530 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25531 wxPyEndAllowThreads(__tstate);
25532 if (PyErr_Occurred()) SWIG_fail;
25533 }
25534 {
25535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25536 }
25537 return resultobj;
25538 fail:
25539 return NULL;
25540 }
25541
25542
25543 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25544 PyObject *resultobj = 0;
25545 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25546 wxString result;
25547 void *argp1 = 0 ;
25548 int res1 = 0 ;
25549 PyObject *swig_obj[1] ;
25550
25551 if (!args) SWIG_fail;
25552 swig_obj[0] = args;
25553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25554 if (!SWIG_IsOK(res1)) {
25555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25556 }
25557 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25558 {
25559 PyThreadState* __tstate = wxPyBeginAllowThreads();
25560 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25561 wxPyEndAllowThreads(__tstate);
25562 if (PyErr_Occurred()) SWIG_fail;
25563 }
25564 {
25565 #if wxUSE_UNICODE
25566 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25567 #else
25568 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25569 #endif
25570 }
25571 return resultobj;
25572 fail:
25573 return NULL;
25574 }
25575
25576
25577 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25578 PyObject *resultobj = 0;
25579 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25580 bool result;
25581 void *argp1 = 0 ;
25582 int res1 = 0 ;
25583 PyObject *swig_obj[1] ;
25584
25585 if (!args) SWIG_fail;
25586 swig_obj[0] = args;
25587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25588 if (!SWIG_IsOK(res1)) {
25589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25590 }
25591 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25592 {
25593 PyThreadState* __tstate = wxPyBeginAllowThreads();
25594 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25595 wxPyEndAllowThreads(__tstate);
25596 if (PyErr_Occurred()) SWIG_fail;
25597 }
25598 {
25599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25600 }
25601 return resultobj;
25602 fail:
25603 return NULL;
25604 }
25605
25606
25607 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25608 PyObject *resultobj = 0;
25609 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25610 bool result;
25611 void *argp1 = 0 ;
25612 int res1 = 0 ;
25613 PyObject *swig_obj[1] ;
25614
25615 if (!args) SWIG_fail;
25616 swig_obj[0] = args;
25617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25618 if (!SWIG_IsOK(res1)) {
25619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25620 }
25621 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25622 {
25623 PyThreadState* __tstate = wxPyBeginAllowThreads();
25624 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25625 wxPyEndAllowThreads(__tstate);
25626 if (PyErr_Occurred()) SWIG_fail;
25627 }
25628 {
25629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25630 }
25631 return resultobj;
25632 fail:
25633 return NULL;
25634 }
25635
25636
25637 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25638 PyObject *resultobj = 0;
25639 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25640 bool result;
25641 void *argp1 = 0 ;
25642 int res1 = 0 ;
25643 PyObject *swig_obj[1] ;
25644
25645 if (!args) SWIG_fail;
25646 swig_obj[0] = args;
25647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25648 if (!SWIG_IsOK(res1)) {
25649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25650 }
25651 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25652 {
25653 PyThreadState* __tstate = wxPyBeginAllowThreads();
25654 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25655 wxPyEndAllowThreads(__tstate);
25656 if (PyErr_Occurred()) SWIG_fail;
25657 }
25658 {
25659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25660 }
25661 return resultobj;
25662 fail:
25663 return NULL;
25664 }
25665
25666
25667 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25668 PyObject *resultobj = 0;
25669 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25670 bool result;
25671 void *argp1 = 0 ;
25672 int res1 = 0 ;
25673 PyObject *swig_obj[1] ;
25674
25675 if (!args) SWIG_fail;
25676 swig_obj[0] = args;
25677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25678 if (!SWIG_IsOK(res1)) {
25679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25680 }
25681 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25682 {
25683 PyThreadState* __tstate = wxPyBeginAllowThreads();
25684 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25685 wxPyEndAllowThreads(__tstate);
25686 if (PyErr_Occurred()) SWIG_fail;
25687 }
25688 {
25689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25690 }
25691 return resultobj;
25692 fail:
25693 return NULL;
25694 }
25695
25696
25697 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25698 PyObject *resultobj = 0;
25699 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25700 bool arg2 ;
25701 void *argp1 = 0 ;
25702 int res1 = 0 ;
25703 bool val2 ;
25704 int ecode2 = 0 ;
25705 PyObject * obj0 = 0 ;
25706 PyObject * obj1 = 0 ;
25707 char * kwnames[] = {
25708 (char *) "self",(char *) "check", NULL
25709 };
25710
25711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25713 if (!SWIG_IsOK(res1)) {
25714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25715 }
25716 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25717 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25718 if (!SWIG_IsOK(ecode2)) {
25719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25720 }
25721 arg2 = static_cast< bool >(val2);
25722 {
25723 PyThreadState* __tstate = wxPyBeginAllowThreads();
25724 (arg1)->Check(arg2);
25725 wxPyEndAllowThreads(__tstate);
25726 if (PyErr_Occurred()) SWIG_fail;
25727 }
25728 resultobj = SWIG_Py_Void();
25729 return resultobj;
25730 fail:
25731 return NULL;
25732 }
25733
25734
25735 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25736 PyObject *resultobj = 0;
25737 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25738 bool arg2 ;
25739 void *argp1 = 0 ;
25740 int res1 = 0 ;
25741 bool val2 ;
25742 int ecode2 = 0 ;
25743 PyObject * obj0 = 0 ;
25744 PyObject * obj1 = 0 ;
25745 char * kwnames[] = {
25746 (char *) "self",(char *) "enable", NULL
25747 };
25748
25749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25751 if (!SWIG_IsOK(res1)) {
25752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25753 }
25754 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25755 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25756 if (!SWIG_IsOK(ecode2)) {
25757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25758 }
25759 arg2 = static_cast< bool >(val2);
25760 {
25761 PyThreadState* __tstate = wxPyBeginAllowThreads();
25762 (arg1)->Enable(arg2);
25763 wxPyEndAllowThreads(__tstate);
25764 if (PyErr_Occurred()) SWIG_fail;
25765 }
25766 resultobj = SWIG_Py_Void();
25767 return resultobj;
25768 fail:
25769 return NULL;
25770 }
25771
25772
25773 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25774 PyObject *resultobj = 0;
25775 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25776 bool arg2 ;
25777 void *argp1 = 0 ;
25778 int res1 = 0 ;
25779 bool val2 ;
25780 int ecode2 = 0 ;
25781 PyObject * obj0 = 0 ;
25782 PyObject * obj1 = 0 ;
25783 char * kwnames[] = {
25784 (char *) "self",(char *) "show", NULL
25785 };
25786
25787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25789 if (!SWIG_IsOK(res1)) {
25790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25791 }
25792 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25793 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25794 if (!SWIG_IsOK(ecode2)) {
25795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25796 }
25797 arg2 = static_cast< bool >(val2);
25798 {
25799 PyThreadState* __tstate = wxPyBeginAllowThreads();
25800 (arg1)->Show(arg2);
25801 wxPyEndAllowThreads(__tstate);
25802 if (PyErr_Occurred()) SWIG_fail;
25803 }
25804 resultobj = SWIG_Py_Void();
25805 return resultobj;
25806 fail:
25807 return NULL;
25808 }
25809
25810
25811 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25812 PyObject *resultobj = 0;
25813 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25814 wxString *arg2 = 0 ;
25815 void *argp1 = 0 ;
25816 int res1 = 0 ;
25817 bool temp2 = false ;
25818 PyObject * obj0 = 0 ;
25819 PyObject * obj1 = 0 ;
25820 char * kwnames[] = {
25821 (char *) "self",(char *) "text", NULL
25822 };
25823
25824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25826 if (!SWIG_IsOK(res1)) {
25827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25828 }
25829 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25830 {
25831 arg2 = wxString_in_helper(obj1);
25832 if (arg2 == NULL) SWIG_fail;
25833 temp2 = true;
25834 }
25835 {
25836 PyThreadState* __tstate = wxPyBeginAllowThreads();
25837 (arg1)->SetText((wxString const &)*arg2);
25838 wxPyEndAllowThreads(__tstate);
25839 if (PyErr_Occurred()) SWIG_fail;
25840 }
25841 resultobj = SWIG_Py_Void();
25842 {
25843 if (temp2)
25844 delete arg2;
25845 }
25846 return resultobj;
25847 fail:
25848 {
25849 if (temp2)
25850 delete arg2;
25851 }
25852 return NULL;
25853 }
25854
25855
25856 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25857 PyObject *resultobj = 0;
25858 long arg1 ;
25859 long val1 ;
25860 int ecode1 = 0 ;
25861 PyObject * obj0 = 0 ;
25862 char * kwnames[] = {
25863 (char *) "updateInterval", NULL
25864 };
25865
25866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25867 ecode1 = SWIG_AsVal_long(obj0, &val1);
25868 if (!SWIG_IsOK(ecode1)) {
25869 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25870 }
25871 arg1 = static_cast< long >(val1);
25872 {
25873 PyThreadState* __tstate = wxPyBeginAllowThreads();
25874 wxUpdateUIEvent::SetUpdateInterval(arg1);
25875 wxPyEndAllowThreads(__tstate);
25876 if (PyErr_Occurred()) SWIG_fail;
25877 }
25878 resultobj = SWIG_Py_Void();
25879 return resultobj;
25880 fail:
25881 return NULL;
25882 }
25883
25884
25885 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25886 PyObject *resultobj = 0;
25887 long result;
25888
25889 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25890 {
25891 PyThreadState* __tstate = wxPyBeginAllowThreads();
25892 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25893 wxPyEndAllowThreads(__tstate);
25894 if (PyErr_Occurred()) SWIG_fail;
25895 }
25896 resultobj = SWIG_From_long(static_cast< long >(result));
25897 return resultobj;
25898 fail:
25899 return NULL;
25900 }
25901
25902
25903 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25904 PyObject *resultobj = 0;
25905 wxWindow *arg1 = (wxWindow *) 0 ;
25906 bool result;
25907 void *argp1 = 0 ;
25908 int res1 = 0 ;
25909 PyObject * obj0 = 0 ;
25910 char * kwnames[] = {
25911 (char *) "win", NULL
25912 };
25913
25914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25916 if (!SWIG_IsOK(res1)) {
25917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25918 }
25919 arg1 = reinterpret_cast< wxWindow * >(argp1);
25920 {
25921 PyThreadState* __tstate = wxPyBeginAllowThreads();
25922 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25923 wxPyEndAllowThreads(__tstate);
25924 if (PyErr_Occurred()) SWIG_fail;
25925 }
25926 {
25927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25928 }
25929 return resultobj;
25930 fail:
25931 return NULL;
25932 }
25933
25934
25935 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25936 PyObject *resultobj = 0;
25937
25938 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25939 {
25940 PyThreadState* __tstate = wxPyBeginAllowThreads();
25941 wxUpdateUIEvent::ResetUpdateTime();
25942 wxPyEndAllowThreads(__tstate);
25943 if (PyErr_Occurred()) SWIG_fail;
25944 }
25945 resultobj = SWIG_Py_Void();
25946 return resultobj;
25947 fail:
25948 return NULL;
25949 }
25950
25951
25952 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25953 PyObject *resultobj = 0;
25954 wxUpdateUIMode arg1 ;
25955 int val1 ;
25956 int ecode1 = 0 ;
25957 PyObject * obj0 = 0 ;
25958 char * kwnames[] = {
25959 (char *) "mode", NULL
25960 };
25961
25962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25963 ecode1 = SWIG_AsVal_int(obj0, &val1);
25964 if (!SWIG_IsOK(ecode1)) {
25965 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25966 }
25967 arg1 = static_cast< wxUpdateUIMode >(val1);
25968 {
25969 PyThreadState* __tstate = wxPyBeginAllowThreads();
25970 wxUpdateUIEvent::SetMode(arg1);
25971 wxPyEndAllowThreads(__tstate);
25972 if (PyErr_Occurred()) SWIG_fail;
25973 }
25974 resultobj = SWIG_Py_Void();
25975 return resultobj;
25976 fail:
25977 return NULL;
25978 }
25979
25980
25981 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25982 PyObject *resultobj = 0;
25983 wxUpdateUIMode result;
25984
25985 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25986 {
25987 PyThreadState* __tstate = wxPyBeginAllowThreads();
25988 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25989 wxPyEndAllowThreads(__tstate);
25990 if (PyErr_Occurred()) SWIG_fail;
25991 }
25992 resultobj = SWIG_From_int(static_cast< int >(result));
25993 return resultobj;
25994 fail:
25995 return NULL;
25996 }
25997
25998
25999 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26000 PyObject *obj;
26001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26002 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
26003 return SWIG_Py_Void();
26004 }
26005
26006 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26007 return SWIG_Python_InitShadowInstance(args);
26008 }
26009
26010 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26011 PyObject *resultobj = 0;
26012 wxSysColourChangedEvent *result = 0 ;
26013
26014 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
26015 {
26016 PyThreadState* __tstate = wxPyBeginAllowThreads();
26017 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
26018 wxPyEndAllowThreads(__tstate);
26019 if (PyErr_Occurred()) SWIG_fail;
26020 }
26021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
26022 return resultobj;
26023 fail:
26024 return NULL;
26025 }
26026
26027
26028 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26029 PyObject *obj;
26030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26031 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
26032 return SWIG_Py_Void();
26033 }
26034
26035 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26036 return SWIG_Python_InitShadowInstance(args);
26037 }
26038
26039 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26040 PyObject *resultobj = 0;
26041 int arg1 = (int) 0 ;
26042 wxWindow *arg2 = (wxWindow *) NULL ;
26043 wxMouseCaptureChangedEvent *result = 0 ;
26044 int val1 ;
26045 int ecode1 = 0 ;
26046 void *argp2 = 0 ;
26047 int res2 = 0 ;
26048 PyObject * obj0 = 0 ;
26049 PyObject * obj1 = 0 ;
26050 char * kwnames[] = {
26051 (char *) "winid",(char *) "gainedCapture", NULL
26052 };
26053
26054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26055 if (obj0) {
26056 ecode1 = SWIG_AsVal_int(obj0, &val1);
26057 if (!SWIG_IsOK(ecode1)) {
26058 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
26059 }
26060 arg1 = static_cast< int >(val1);
26061 }
26062 if (obj1) {
26063 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26064 if (!SWIG_IsOK(res2)) {
26065 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
26066 }
26067 arg2 = reinterpret_cast< wxWindow * >(argp2);
26068 }
26069 {
26070 PyThreadState* __tstate = wxPyBeginAllowThreads();
26071 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
26072 wxPyEndAllowThreads(__tstate);
26073 if (PyErr_Occurred()) SWIG_fail;
26074 }
26075 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
26076 return resultobj;
26077 fail:
26078 return NULL;
26079 }
26080
26081
26082 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26083 PyObject *resultobj = 0;
26084 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
26085 wxWindow *result = 0 ;
26086 void *argp1 = 0 ;
26087 int res1 = 0 ;
26088 PyObject *swig_obj[1] ;
26089
26090 if (!args) SWIG_fail;
26091 swig_obj[0] = args;
26092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
26093 if (!SWIG_IsOK(res1)) {
26094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
26095 }
26096 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
26097 {
26098 PyThreadState* __tstate = wxPyBeginAllowThreads();
26099 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
26100 wxPyEndAllowThreads(__tstate);
26101 if (PyErr_Occurred()) SWIG_fail;
26102 }
26103 {
26104 resultobj = wxPyMake_wxObject(result, (bool)0);
26105 }
26106 return resultobj;
26107 fail:
26108 return NULL;
26109 }
26110
26111
26112 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26113 PyObject *obj;
26114 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26115 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
26116 return SWIG_Py_Void();
26117 }
26118
26119 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26120 return SWIG_Python_InitShadowInstance(args);
26121 }
26122
26123 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26124 PyObject *resultobj = 0;
26125 int arg1 = (int) 0 ;
26126 wxMouseCaptureLostEvent *result = 0 ;
26127 int val1 ;
26128 int ecode1 = 0 ;
26129 PyObject * obj0 = 0 ;
26130 char * kwnames[] = {
26131 (char *) "winid", NULL
26132 };
26133
26134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
26135 if (obj0) {
26136 ecode1 = SWIG_AsVal_int(obj0, &val1);
26137 if (!SWIG_IsOK(ecode1)) {
26138 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
26139 }
26140 arg1 = static_cast< int >(val1);
26141 }
26142 {
26143 PyThreadState* __tstate = wxPyBeginAllowThreads();
26144 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
26145 wxPyEndAllowThreads(__tstate);
26146 if (PyErr_Occurred()) SWIG_fail;
26147 }
26148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
26149 return resultobj;
26150 fail:
26151 return NULL;
26152 }
26153
26154
26155 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26156 PyObject *obj;
26157 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26158 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
26159 return SWIG_Py_Void();
26160 }
26161
26162 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26163 return SWIG_Python_InitShadowInstance(args);
26164 }
26165
26166 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26167 PyObject *resultobj = 0;
26168 wxDisplayChangedEvent *result = 0 ;
26169
26170 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
26171 {
26172 PyThreadState* __tstate = wxPyBeginAllowThreads();
26173 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
26174 wxPyEndAllowThreads(__tstate);
26175 if (PyErr_Occurred()) SWIG_fail;
26176 }
26177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
26178 return resultobj;
26179 fail:
26180 return NULL;
26181 }
26182
26183
26184 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26185 PyObject *obj;
26186 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26187 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
26188 return SWIG_Py_Void();
26189 }
26190
26191 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26192 return SWIG_Python_InitShadowInstance(args);
26193 }
26194
26195 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26196 PyObject *resultobj = 0;
26197 int arg1 = (int) 0 ;
26198 wxPaletteChangedEvent *result = 0 ;
26199 int val1 ;
26200 int ecode1 = 0 ;
26201 PyObject * obj0 = 0 ;
26202 char * kwnames[] = {
26203 (char *) "id", NULL
26204 };
26205
26206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
26207 if (obj0) {
26208 ecode1 = SWIG_AsVal_int(obj0, &val1);
26209 if (!SWIG_IsOK(ecode1)) {
26210 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
26211 }
26212 arg1 = static_cast< int >(val1);
26213 }
26214 {
26215 PyThreadState* __tstate = wxPyBeginAllowThreads();
26216 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
26217 wxPyEndAllowThreads(__tstate);
26218 if (PyErr_Occurred()) SWIG_fail;
26219 }
26220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
26221 return resultobj;
26222 fail:
26223 return NULL;
26224 }
26225
26226
26227 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26228 PyObject *resultobj = 0;
26229 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26230 wxWindow *arg2 = (wxWindow *) 0 ;
26231 void *argp1 = 0 ;
26232 int res1 = 0 ;
26233 void *argp2 = 0 ;
26234 int res2 = 0 ;
26235 PyObject * obj0 = 0 ;
26236 PyObject * obj1 = 0 ;
26237 char * kwnames[] = {
26238 (char *) "self",(char *) "win", NULL
26239 };
26240
26241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26243 if (!SWIG_IsOK(res1)) {
26244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26245 }
26246 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26248 if (!SWIG_IsOK(res2)) {
26249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26250 }
26251 arg2 = reinterpret_cast< wxWindow * >(argp2);
26252 {
26253 PyThreadState* __tstate = wxPyBeginAllowThreads();
26254 (arg1)->SetChangedWindow(arg2);
26255 wxPyEndAllowThreads(__tstate);
26256 if (PyErr_Occurred()) SWIG_fail;
26257 }
26258 resultobj = SWIG_Py_Void();
26259 return resultobj;
26260 fail:
26261 return NULL;
26262 }
26263
26264
26265 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26266 PyObject *resultobj = 0;
26267 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26268 wxWindow *result = 0 ;
26269 void *argp1 = 0 ;
26270 int res1 = 0 ;
26271 PyObject *swig_obj[1] ;
26272
26273 if (!args) SWIG_fail;
26274 swig_obj[0] = args;
26275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26276 if (!SWIG_IsOK(res1)) {
26277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26278 }
26279 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26280 {
26281 PyThreadState* __tstate = wxPyBeginAllowThreads();
26282 result = (wxWindow *)(arg1)->GetChangedWindow();
26283 wxPyEndAllowThreads(__tstate);
26284 if (PyErr_Occurred()) SWIG_fail;
26285 }
26286 {
26287 resultobj = wxPyMake_wxObject(result, (bool)0);
26288 }
26289 return resultobj;
26290 fail:
26291 return NULL;
26292 }
26293
26294
26295 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26296 PyObject *obj;
26297 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26298 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
26299 return SWIG_Py_Void();
26300 }
26301
26302 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26303 return SWIG_Python_InitShadowInstance(args);
26304 }
26305
26306 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26307 PyObject *resultobj = 0;
26308 int arg1 = (int) 0 ;
26309 wxQueryNewPaletteEvent *result = 0 ;
26310 int val1 ;
26311 int ecode1 = 0 ;
26312 PyObject * obj0 = 0 ;
26313 char * kwnames[] = {
26314 (char *) "winid", NULL
26315 };
26316
26317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
26318 if (obj0) {
26319 ecode1 = SWIG_AsVal_int(obj0, &val1);
26320 if (!SWIG_IsOK(ecode1)) {
26321 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
26322 }
26323 arg1 = static_cast< int >(val1);
26324 }
26325 {
26326 PyThreadState* __tstate = wxPyBeginAllowThreads();
26327 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
26328 wxPyEndAllowThreads(__tstate);
26329 if (PyErr_Occurred()) SWIG_fail;
26330 }
26331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
26332 return resultobj;
26333 fail:
26334 return NULL;
26335 }
26336
26337
26338 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26339 PyObject *resultobj = 0;
26340 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26341 bool arg2 ;
26342 void *argp1 = 0 ;
26343 int res1 = 0 ;
26344 bool val2 ;
26345 int ecode2 = 0 ;
26346 PyObject * obj0 = 0 ;
26347 PyObject * obj1 = 0 ;
26348 char * kwnames[] = {
26349 (char *) "self",(char *) "realized", NULL
26350 };
26351
26352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
26353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26354 if (!SWIG_IsOK(res1)) {
26355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
26356 }
26357 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26358 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26359 if (!SWIG_IsOK(ecode2)) {
26360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
26361 }
26362 arg2 = static_cast< bool >(val2);
26363 {
26364 PyThreadState* __tstate = wxPyBeginAllowThreads();
26365 (arg1)->SetPaletteRealized(arg2);
26366 wxPyEndAllowThreads(__tstate);
26367 if (PyErr_Occurred()) SWIG_fail;
26368 }
26369 resultobj = SWIG_Py_Void();
26370 return resultobj;
26371 fail:
26372 return NULL;
26373 }
26374
26375
26376 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26377 PyObject *resultobj = 0;
26378 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26379 bool result;
26380 void *argp1 = 0 ;
26381 int res1 = 0 ;
26382 PyObject *swig_obj[1] ;
26383
26384 if (!args) SWIG_fail;
26385 swig_obj[0] = args;
26386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26387 if (!SWIG_IsOK(res1)) {
26388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
26389 }
26390 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26391 {
26392 PyThreadState* __tstate = wxPyBeginAllowThreads();
26393 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
26394 wxPyEndAllowThreads(__tstate);
26395 if (PyErr_Occurred()) SWIG_fail;
26396 }
26397 {
26398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26399 }
26400 return resultobj;
26401 fail:
26402 return NULL;
26403 }
26404
26405
26406 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26407 PyObject *obj;
26408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26409 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
26410 return SWIG_Py_Void();
26411 }
26412
26413 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26414 return SWIG_Python_InitShadowInstance(args);
26415 }
26416
26417 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26418 PyObject *resultobj = 0;
26419 wxNavigationKeyEvent *result = 0 ;
26420
26421 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
26422 {
26423 PyThreadState* __tstate = wxPyBeginAllowThreads();
26424 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
26425 wxPyEndAllowThreads(__tstate);
26426 if (PyErr_Occurred()) SWIG_fail;
26427 }
26428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
26429 return resultobj;
26430 fail:
26431 return NULL;
26432 }
26433
26434
26435 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26436 PyObject *resultobj = 0;
26437 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26438 bool result;
26439 void *argp1 = 0 ;
26440 int res1 = 0 ;
26441 PyObject *swig_obj[1] ;
26442
26443 if (!args) SWIG_fail;
26444 swig_obj[0] = args;
26445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26446 if (!SWIG_IsOK(res1)) {
26447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26448 }
26449 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26450 {
26451 PyThreadState* __tstate = wxPyBeginAllowThreads();
26452 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26453 wxPyEndAllowThreads(__tstate);
26454 if (PyErr_Occurred()) SWIG_fail;
26455 }
26456 {
26457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26458 }
26459 return resultobj;
26460 fail:
26461 return NULL;
26462 }
26463
26464
26465 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26466 PyObject *resultobj = 0;
26467 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26468 bool arg2 ;
26469 void *argp1 = 0 ;
26470 int res1 = 0 ;
26471 bool val2 ;
26472 int ecode2 = 0 ;
26473 PyObject * obj0 = 0 ;
26474 PyObject * obj1 = 0 ;
26475 char * kwnames[] = {
26476 (char *) "self",(char *) "forward", NULL
26477 };
26478
26479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26481 if (!SWIG_IsOK(res1)) {
26482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26483 }
26484 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26485 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26486 if (!SWIG_IsOK(ecode2)) {
26487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26488 }
26489 arg2 = static_cast< bool >(val2);
26490 {
26491 PyThreadState* __tstate = wxPyBeginAllowThreads();
26492 (arg1)->SetDirection(arg2);
26493 wxPyEndAllowThreads(__tstate);
26494 if (PyErr_Occurred()) SWIG_fail;
26495 }
26496 resultobj = SWIG_Py_Void();
26497 return resultobj;
26498 fail:
26499 return NULL;
26500 }
26501
26502
26503 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26504 PyObject *resultobj = 0;
26505 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26506 bool result;
26507 void *argp1 = 0 ;
26508 int res1 = 0 ;
26509 PyObject *swig_obj[1] ;
26510
26511 if (!args) SWIG_fail;
26512 swig_obj[0] = args;
26513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26514 if (!SWIG_IsOK(res1)) {
26515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26516 }
26517 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26518 {
26519 PyThreadState* __tstate = wxPyBeginAllowThreads();
26520 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26521 wxPyEndAllowThreads(__tstate);
26522 if (PyErr_Occurred()) SWIG_fail;
26523 }
26524 {
26525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26526 }
26527 return resultobj;
26528 fail:
26529 return NULL;
26530 }
26531
26532
26533 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26534 PyObject *resultobj = 0;
26535 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26536 bool arg2 ;
26537 void *argp1 = 0 ;
26538 int res1 = 0 ;
26539 bool val2 ;
26540 int ecode2 = 0 ;
26541 PyObject * obj0 = 0 ;
26542 PyObject * obj1 = 0 ;
26543 char * kwnames[] = {
26544 (char *) "self",(char *) "ischange", NULL
26545 };
26546
26547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26549 if (!SWIG_IsOK(res1)) {
26550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26551 }
26552 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26553 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26554 if (!SWIG_IsOK(ecode2)) {
26555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26556 }
26557 arg2 = static_cast< bool >(val2);
26558 {
26559 PyThreadState* __tstate = wxPyBeginAllowThreads();
26560 (arg1)->SetWindowChange(arg2);
26561 wxPyEndAllowThreads(__tstate);
26562 if (PyErr_Occurred()) SWIG_fail;
26563 }
26564 resultobj = SWIG_Py_Void();
26565 return resultobj;
26566 fail:
26567 return NULL;
26568 }
26569
26570
26571 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26572 PyObject *resultobj = 0;
26573 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26574 bool result;
26575 void *argp1 = 0 ;
26576 int res1 = 0 ;
26577 PyObject *swig_obj[1] ;
26578
26579 if (!args) SWIG_fail;
26580 swig_obj[0] = args;
26581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26582 if (!SWIG_IsOK(res1)) {
26583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26584 }
26585 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26586 {
26587 PyThreadState* __tstate = wxPyBeginAllowThreads();
26588 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26589 wxPyEndAllowThreads(__tstate);
26590 if (PyErr_Occurred()) SWIG_fail;
26591 }
26592 {
26593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26594 }
26595 return resultobj;
26596 fail:
26597 return NULL;
26598 }
26599
26600
26601 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26602 PyObject *resultobj = 0;
26603 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26604 bool arg2 ;
26605 void *argp1 = 0 ;
26606 int res1 = 0 ;
26607 bool val2 ;
26608 int ecode2 = 0 ;
26609 PyObject * obj0 = 0 ;
26610 PyObject * obj1 = 0 ;
26611 char * kwnames[] = {
26612 (char *) "self",(char *) "bIs", NULL
26613 };
26614
26615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26617 if (!SWIG_IsOK(res1)) {
26618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26619 }
26620 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26621 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26622 if (!SWIG_IsOK(ecode2)) {
26623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26624 }
26625 arg2 = static_cast< bool >(val2);
26626 {
26627 PyThreadState* __tstate = wxPyBeginAllowThreads();
26628 (arg1)->SetFromTab(arg2);
26629 wxPyEndAllowThreads(__tstate);
26630 if (PyErr_Occurred()) SWIG_fail;
26631 }
26632 resultobj = SWIG_Py_Void();
26633 return resultobj;
26634 fail:
26635 return NULL;
26636 }
26637
26638
26639 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26640 PyObject *resultobj = 0;
26641 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26642 long arg2 ;
26643 void *argp1 = 0 ;
26644 int res1 = 0 ;
26645 long val2 ;
26646 int ecode2 = 0 ;
26647 PyObject * obj0 = 0 ;
26648 PyObject * obj1 = 0 ;
26649 char * kwnames[] = {
26650 (char *) "self",(char *) "flags", NULL
26651 };
26652
26653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26655 if (!SWIG_IsOK(res1)) {
26656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26657 }
26658 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26659 ecode2 = SWIG_AsVal_long(obj1, &val2);
26660 if (!SWIG_IsOK(ecode2)) {
26661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26662 }
26663 arg2 = static_cast< long >(val2);
26664 {
26665 PyThreadState* __tstate = wxPyBeginAllowThreads();
26666 (arg1)->SetFlags(arg2);
26667 wxPyEndAllowThreads(__tstate);
26668 if (PyErr_Occurred()) SWIG_fail;
26669 }
26670 resultobj = SWIG_Py_Void();
26671 return resultobj;
26672 fail:
26673 return NULL;
26674 }
26675
26676
26677 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26678 PyObject *resultobj = 0;
26679 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26680 wxWindow *result = 0 ;
26681 void *argp1 = 0 ;
26682 int res1 = 0 ;
26683 PyObject *swig_obj[1] ;
26684
26685 if (!args) SWIG_fail;
26686 swig_obj[0] = args;
26687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26688 if (!SWIG_IsOK(res1)) {
26689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26690 }
26691 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26692 {
26693 PyThreadState* __tstate = wxPyBeginAllowThreads();
26694 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26695 wxPyEndAllowThreads(__tstate);
26696 if (PyErr_Occurred()) SWIG_fail;
26697 }
26698 {
26699 resultobj = wxPyMake_wxObject(result, (bool)0);
26700 }
26701 return resultobj;
26702 fail:
26703 return NULL;
26704 }
26705
26706
26707 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26708 PyObject *resultobj = 0;
26709 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26710 wxWindow *arg2 = (wxWindow *) 0 ;
26711 void *argp1 = 0 ;
26712 int res1 = 0 ;
26713 void *argp2 = 0 ;
26714 int res2 = 0 ;
26715 PyObject * obj0 = 0 ;
26716 PyObject * obj1 = 0 ;
26717 char * kwnames[] = {
26718 (char *) "self",(char *) "win", NULL
26719 };
26720
26721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26723 if (!SWIG_IsOK(res1)) {
26724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26725 }
26726 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26727 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26728 if (!SWIG_IsOK(res2)) {
26729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26730 }
26731 arg2 = reinterpret_cast< wxWindow * >(argp2);
26732 {
26733 PyThreadState* __tstate = wxPyBeginAllowThreads();
26734 (arg1)->SetCurrentFocus(arg2);
26735 wxPyEndAllowThreads(__tstate);
26736 if (PyErr_Occurred()) SWIG_fail;
26737 }
26738 resultobj = SWIG_Py_Void();
26739 return resultobj;
26740 fail:
26741 return NULL;
26742 }
26743
26744
26745 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26746 PyObject *obj;
26747 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26748 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26749 return SWIG_Py_Void();
26750 }
26751
26752 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26753 return SWIG_Python_InitShadowInstance(args);
26754 }
26755
26756 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26757 PyObject *resultobj = 0;
26758 wxWindow *arg1 = (wxWindow *) NULL ;
26759 wxWindowCreateEvent *result = 0 ;
26760 void *argp1 = 0 ;
26761 int res1 = 0 ;
26762 PyObject * obj0 = 0 ;
26763 char * kwnames[] = {
26764 (char *) "win", NULL
26765 };
26766
26767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26768 if (obj0) {
26769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26770 if (!SWIG_IsOK(res1)) {
26771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26772 }
26773 arg1 = reinterpret_cast< wxWindow * >(argp1);
26774 }
26775 {
26776 PyThreadState* __tstate = wxPyBeginAllowThreads();
26777 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26778 wxPyEndAllowThreads(__tstate);
26779 if (PyErr_Occurred()) SWIG_fail;
26780 }
26781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26782 return resultobj;
26783 fail:
26784 return NULL;
26785 }
26786
26787
26788 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26789 PyObject *resultobj = 0;
26790 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26791 wxWindow *result = 0 ;
26792 void *argp1 = 0 ;
26793 int res1 = 0 ;
26794 PyObject *swig_obj[1] ;
26795
26796 if (!args) SWIG_fail;
26797 swig_obj[0] = args;
26798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26799 if (!SWIG_IsOK(res1)) {
26800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26801 }
26802 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26803 {
26804 PyThreadState* __tstate = wxPyBeginAllowThreads();
26805 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26806 wxPyEndAllowThreads(__tstate);
26807 if (PyErr_Occurred()) SWIG_fail;
26808 }
26809 {
26810 resultobj = wxPyMake_wxObject(result, (bool)0);
26811 }
26812 return resultobj;
26813 fail:
26814 return NULL;
26815 }
26816
26817
26818 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26819 PyObject *obj;
26820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26821 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26822 return SWIG_Py_Void();
26823 }
26824
26825 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26826 return SWIG_Python_InitShadowInstance(args);
26827 }
26828
26829 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26830 PyObject *resultobj = 0;
26831 wxWindow *arg1 = (wxWindow *) NULL ;
26832 wxWindowDestroyEvent *result = 0 ;
26833 void *argp1 = 0 ;
26834 int res1 = 0 ;
26835 PyObject * obj0 = 0 ;
26836 char * kwnames[] = {
26837 (char *) "win", NULL
26838 };
26839
26840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26841 if (obj0) {
26842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26843 if (!SWIG_IsOK(res1)) {
26844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26845 }
26846 arg1 = reinterpret_cast< wxWindow * >(argp1);
26847 }
26848 {
26849 PyThreadState* __tstate = wxPyBeginAllowThreads();
26850 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26851 wxPyEndAllowThreads(__tstate);
26852 if (PyErr_Occurred()) SWIG_fail;
26853 }
26854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26855 return resultobj;
26856 fail:
26857 return NULL;
26858 }
26859
26860
26861 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26862 PyObject *resultobj = 0;
26863 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26864 wxWindow *result = 0 ;
26865 void *argp1 = 0 ;
26866 int res1 = 0 ;
26867 PyObject *swig_obj[1] ;
26868
26869 if (!args) SWIG_fail;
26870 swig_obj[0] = args;
26871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26872 if (!SWIG_IsOK(res1)) {
26873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26874 }
26875 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26876 {
26877 PyThreadState* __tstate = wxPyBeginAllowThreads();
26878 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26879 wxPyEndAllowThreads(__tstate);
26880 if (PyErr_Occurred()) SWIG_fail;
26881 }
26882 {
26883 resultobj = wxPyMake_wxObject(result, (bool)0);
26884 }
26885 return resultobj;
26886 fail:
26887 return NULL;
26888 }
26889
26890
26891 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26892 PyObject *obj;
26893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26894 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26895 return SWIG_Py_Void();
26896 }
26897
26898 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26899 return SWIG_Python_InitShadowInstance(args);
26900 }
26901
26902 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26903 PyObject *resultobj = 0;
26904 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26905 int arg2 = (int) 0 ;
26906 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26907 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26908 wxContextMenuEvent *result = 0 ;
26909 int val1 ;
26910 int ecode1 = 0 ;
26911 int val2 ;
26912 int ecode2 = 0 ;
26913 wxPoint temp3 ;
26914 PyObject * obj0 = 0 ;
26915 PyObject * obj1 = 0 ;
26916 PyObject * obj2 = 0 ;
26917 char * kwnames[] = {
26918 (char *) "type",(char *) "winid",(char *) "pt", NULL
26919 };
26920
26921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26922 if (obj0) {
26923 ecode1 = SWIG_AsVal_int(obj0, &val1);
26924 if (!SWIG_IsOK(ecode1)) {
26925 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26926 }
26927 arg1 = static_cast< wxEventType >(val1);
26928 }
26929 if (obj1) {
26930 ecode2 = SWIG_AsVal_int(obj1, &val2);
26931 if (!SWIG_IsOK(ecode2)) {
26932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26933 }
26934 arg2 = static_cast< int >(val2);
26935 }
26936 if (obj2) {
26937 {
26938 arg3 = &temp3;
26939 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26940 }
26941 }
26942 {
26943 PyThreadState* __tstate = wxPyBeginAllowThreads();
26944 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26945 wxPyEndAllowThreads(__tstate);
26946 if (PyErr_Occurred()) SWIG_fail;
26947 }
26948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26949 return resultobj;
26950 fail:
26951 return NULL;
26952 }
26953
26954
26955 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26956 PyObject *resultobj = 0;
26957 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26958 wxPoint *result = 0 ;
26959 void *argp1 = 0 ;
26960 int res1 = 0 ;
26961 PyObject *swig_obj[1] ;
26962
26963 if (!args) SWIG_fail;
26964 swig_obj[0] = args;
26965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26966 if (!SWIG_IsOK(res1)) {
26967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26968 }
26969 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26970 {
26971 PyThreadState* __tstate = wxPyBeginAllowThreads();
26972 {
26973 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26974 result = (wxPoint *) &_result_ref;
26975 }
26976 wxPyEndAllowThreads(__tstate);
26977 if (PyErr_Occurred()) SWIG_fail;
26978 }
26979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26980 return resultobj;
26981 fail:
26982 return NULL;
26983 }
26984
26985
26986 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26987 PyObject *resultobj = 0;
26988 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26989 wxPoint *arg2 = 0 ;
26990 void *argp1 = 0 ;
26991 int res1 = 0 ;
26992 wxPoint temp2 ;
26993 PyObject * obj0 = 0 ;
26994 PyObject * obj1 = 0 ;
26995 char * kwnames[] = {
26996 (char *) "self",(char *) "pos", NULL
26997 };
26998
26999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
27000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27001 if (!SWIG_IsOK(res1)) {
27002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
27003 }
27004 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27005 {
27006 arg2 = &temp2;
27007 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27008 }
27009 {
27010 PyThreadState* __tstate = wxPyBeginAllowThreads();
27011 (arg1)->SetPosition((wxPoint const &)*arg2);
27012 wxPyEndAllowThreads(__tstate);
27013 if (PyErr_Occurred()) SWIG_fail;
27014 }
27015 resultobj = SWIG_Py_Void();
27016 return resultobj;
27017 fail:
27018 return NULL;
27019 }
27020
27021
27022 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27023 PyObject *obj;
27024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27025 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
27026 return SWIG_Py_Void();
27027 }
27028
27029 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27030 return SWIG_Python_InitShadowInstance(args);
27031 }
27032
27033 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27034 PyObject *resultobj = 0;
27035 wxIdleEvent *result = 0 ;
27036
27037 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
27038 {
27039 PyThreadState* __tstate = wxPyBeginAllowThreads();
27040 result = (wxIdleEvent *)new wxIdleEvent();
27041 wxPyEndAllowThreads(__tstate);
27042 if (PyErr_Occurred()) SWIG_fail;
27043 }
27044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
27045 return resultobj;
27046 fail:
27047 return NULL;
27048 }
27049
27050
27051 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27052 PyObject *resultobj = 0;
27053 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27054 bool arg2 = (bool) true ;
27055 void *argp1 = 0 ;
27056 int res1 = 0 ;
27057 bool val2 ;
27058 int ecode2 = 0 ;
27059 PyObject * obj0 = 0 ;
27060 PyObject * obj1 = 0 ;
27061 char * kwnames[] = {
27062 (char *) "self",(char *) "needMore", NULL
27063 };
27064
27065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
27066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27067 if (!SWIG_IsOK(res1)) {
27068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
27069 }
27070 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27071 if (obj1) {
27072 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27073 if (!SWIG_IsOK(ecode2)) {
27074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
27075 }
27076 arg2 = static_cast< bool >(val2);
27077 }
27078 {
27079 PyThreadState* __tstate = wxPyBeginAllowThreads();
27080 (arg1)->RequestMore(arg2);
27081 wxPyEndAllowThreads(__tstate);
27082 if (PyErr_Occurred()) SWIG_fail;
27083 }
27084 resultobj = SWIG_Py_Void();
27085 return resultobj;
27086 fail:
27087 return NULL;
27088 }
27089
27090
27091 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27092 PyObject *resultobj = 0;
27093 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27094 bool result;
27095 void *argp1 = 0 ;
27096 int res1 = 0 ;
27097 PyObject *swig_obj[1] ;
27098
27099 if (!args) SWIG_fail;
27100 swig_obj[0] = args;
27101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27102 if (!SWIG_IsOK(res1)) {
27103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
27104 }
27105 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27106 {
27107 PyThreadState* __tstate = wxPyBeginAllowThreads();
27108 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
27109 wxPyEndAllowThreads(__tstate);
27110 if (PyErr_Occurred()) SWIG_fail;
27111 }
27112 {
27113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27114 }
27115 return resultobj;
27116 fail:
27117 return NULL;
27118 }
27119
27120
27121 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27122 PyObject *resultobj = 0;
27123 wxIdleMode arg1 ;
27124 int val1 ;
27125 int ecode1 = 0 ;
27126 PyObject * obj0 = 0 ;
27127 char * kwnames[] = {
27128 (char *) "mode", NULL
27129 };
27130
27131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
27132 ecode1 = SWIG_AsVal_int(obj0, &val1);
27133 if (!SWIG_IsOK(ecode1)) {
27134 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
27135 }
27136 arg1 = static_cast< wxIdleMode >(val1);
27137 {
27138 PyThreadState* __tstate = wxPyBeginAllowThreads();
27139 wxIdleEvent::SetMode(arg1);
27140 wxPyEndAllowThreads(__tstate);
27141 if (PyErr_Occurred()) SWIG_fail;
27142 }
27143 resultobj = SWIG_Py_Void();
27144 return resultobj;
27145 fail:
27146 return NULL;
27147 }
27148
27149
27150 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27151 PyObject *resultobj = 0;
27152 wxIdleMode result;
27153
27154 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
27155 {
27156 PyThreadState* __tstate = wxPyBeginAllowThreads();
27157 result = (wxIdleMode)wxIdleEvent::GetMode();
27158 wxPyEndAllowThreads(__tstate);
27159 if (PyErr_Occurred()) SWIG_fail;
27160 }
27161 resultobj = SWIG_From_int(static_cast< int >(result));
27162 return resultobj;
27163 fail:
27164 return NULL;
27165 }
27166
27167
27168 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27169 PyObject *resultobj = 0;
27170 wxWindow *arg1 = (wxWindow *) 0 ;
27171 bool result;
27172 void *argp1 = 0 ;
27173 int res1 = 0 ;
27174 PyObject * obj0 = 0 ;
27175 char * kwnames[] = {
27176 (char *) "win", NULL
27177 };
27178
27179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
27180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27181 if (!SWIG_IsOK(res1)) {
27182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
27183 }
27184 arg1 = reinterpret_cast< wxWindow * >(argp1);
27185 {
27186 PyThreadState* __tstate = wxPyBeginAllowThreads();
27187 result = (bool)wxIdleEvent::CanSend(arg1);
27188 wxPyEndAllowThreads(__tstate);
27189 if (PyErr_Occurred()) SWIG_fail;
27190 }
27191 {
27192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27193 }
27194 return resultobj;
27195 fail:
27196 return NULL;
27197 }
27198
27199
27200 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27201 PyObject *obj;
27202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27203 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
27204 return SWIG_Py_Void();
27205 }
27206
27207 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27208 return SWIG_Python_InitShadowInstance(args);
27209 }
27210
27211 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27212 PyObject *resultobj = 0;
27213 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27214 int arg2 = (int) 0 ;
27215 wxClipboardTextEvent *result = 0 ;
27216 int val1 ;
27217 int ecode1 = 0 ;
27218 int val2 ;
27219 int ecode2 = 0 ;
27220 PyObject * obj0 = 0 ;
27221 PyObject * obj1 = 0 ;
27222 char * kwnames[] = {
27223 (char *) "type",(char *) "winid", NULL
27224 };
27225
27226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27227 if (obj0) {
27228 ecode1 = SWIG_AsVal_int(obj0, &val1);
27229 if (!SWIG_IsOK(ecode1)) {
27230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27231 }
27232 arg1 = static_cast< wxEventType >(val1);
27233 }
27234 if (obj1) {
27235 ecode2 = SWIG_AsVal_int(obj1, &val2);
27236 if (!SWIG_IsOK(ecode2)) {
27237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
27238 }
27239 arg2 = static_cast< int >(val2);
27240 }
27241 {
27242 PyThreadState* __tstate = wxPyBeginAllowThreads();
27243 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
27244 wxPyEndAllowThreads(__tstate);
27245 if (PyErr_Occurred()) SWIG_fail;
27246 }
27247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
27248 return resultobj;
27249 fail:
27250 return NULL;
27251 }
27252
27253
27254 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27255 PyObject *obj;
27256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27257 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
27258 return SWIG_Py_Void();
27259 }
27260
27261 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27262 return SWIG_Python_InitShadowInstance(args);
27263 }
27264
27265 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27266 PyObject *resultobj = 0;
27267 int arg1 = (int) 0 ;
27268 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
27269 wxPyEvent *result = 0 ;
27270 int val1 ;
27271 int ecode1 = 0 ;
27272 int val2 ;
27273 int ecode2 = 0 ;
27274 PyObject * obj0 = 0 ;
27275 PyObject * obj1 = 0 ;
27276 char * kwnames[] = {
27277 (char *) "winid",(char *) "eventType", NULL
27278 };
27279
27280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27281 if (obj0) {
27282 ecode1 = SWIG_AsVal_int(obj0, &val1);
27283 if (!SWIG_IsOK(ecode1)) {
27284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
27285 }
27286 arg1 = static_cast< int >(val1);
27287 }
27288 if (obj1) {
27289 ecode2 = SWIG_AsVal_int(obj1, &val2);
27290 if (!SWIG_IsOK(ecode2)) {
27291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
27292 }
27293 arg2 = static_cast< wxEventType >(val2);
27294 }
27295 {
27296 PyThreadState* __tstate = wxPyBeginAllowThreads();
27297 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
27298 wxPyEndAllowThreads(__tstate);
27299 if (PyErr_Occurred()) SWIG_fail;
27300 }
27301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
27302 return resultobj;
27303 fail:
27304 return NULL;
27305 }
27306
27307
27308 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27309 PyObject *resultobj = 0;
27310 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27311 void *argp1 = 0 ;
27312 int res1 = 0 ;
27313 PyObject *swig_obj[1] ;
27314
27315 if (!args) SWIG_fail;
27316 swig_obj[0] = args;
27317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
27318 if (!SWIG_IsOK(res1)) {
27319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27320 }
27321 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27322 {
27323 PyThreadState* __tstate = wxPyBeginAllowThreads();
27324 delete arg1;
27325
27326 wxPyEndAllowThreads(__tstate);
27327 if (PyErr_Occurred()) SWIG_fail;
27328 }
27329 resultobj = SWIG_Py_Void();
27330 return resultobj;
27331 fail:
27332 return NULL;
27333 }
27334
27335
27336 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27337 PyObject *resultobj = 0;
27338 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27339 PyObject *arg2 = (PyObject *) 0 ;
27340 void *argp1 = 0 ;
27341 int res1 = 0 ;
27342 PyObject * obj0 = 0 ;
27343 PyObject * obj1 = 0 ;
27344 char * kwnames[] = {
27345 (char *) "self",(char *) "self", NULL
27346 };
27347
27348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27350 if (!SWIG_IsOK(res1)) {
27351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27352 }
27353 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27354 arg2 = obj1;
27355 {
27356 PyThreadState* __tstate = wxPyBeginAllowThreads();
27357 (arg1)->SetSelf(arg2);
27358 wxPyEndAllowThreads(__tstate);
27359 if (PyErr_Occurred()) SWIG_fail;
27360 }
27361 resultobj = SWIG_Py_Void();
27362 return resultobj;
27363 fail:
27364 return NULL;
27365 }
27366
27367
27368 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27369 PyObject *resultobj = 0;
27370 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27371 PyObject *result = 0 ;
27372 void *argp1 = 0 ;
27373 int res1 = 0 ;
27374 PyObject *swig_obj[1] ;
27375
27376 if (!args) SWIG_fail;
27377 swig_obj[0] = args;
27378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27379 if (!SWIG_IsOK(res1)) {
27380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27381 }
27382 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27383 {
27384 PyThreadState* __tstate = wxPyBeginAllowThreads();
27385 result = (PyObject *)(arg1)->GetSelf();
27386 wxPyEndAllowThreads(__tstate);
27387 if (PyErr_Occurred()) SWIG_fail;
27388 }
27389 resultobj = result;
27390 return resultobj;
27391 fail:
27392 return NULL;
27393 }
27394
27395
27396 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27397 PyObject *obj;
27398 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27399 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
27400 return SWIG_Py_Void();
27401 }
27402
27403 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27404 return SWIG_Python_InitShadowInstance(args);
27405 }
27406
27407 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27408 PyObject *resultobj = 0;
27409 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27410 int arg2 = (int) 0 ;
27411 wxPyCommandEvent *result = 0 ;
27412 int val1 ;
27413 int ecode1 = 0 ;
27414 int val2 ;
27415 int ecode2 = 0 ;
27416 PyObject * obj0 = 0 ;
27417 PyObject * obj1 = 0 ;
27418 char * kwnames[] = {
27419 (char *) "eventType",(char *) "id", NULL
27420 };
27421
27422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27423 if (obj0) {
27424 ecode1 = SWIG_AsVal_int(obj0, &val1);
27425 if (!SWIG_IsOK(ecode1)) {
27426 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27427 }
27428 arg1 = static_cast< wxEventType >(val1);
27429 }
27430 if (obj1) {
27431 ecode2 = SWIG_AsVal_int(obj1, &val2);
27432 if (!SWIG_IsOK(ecode2)) {
27433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
27434 }
27435 arg2 = static_cast< int >(val2);
27436 }
27437 {
27438 PyThreadState* __tstate = wxPyBeginAllowThreads();
27439 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
27440 wxPyEndAllowThreads(__tstate);
27441 if (PyErr_Occurred()) SWIG_fail;
27442 }
27443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27444 return resultobj;
27445 fail:
27446 return NULL;
27447 }
27448
27449
27450 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27451 PyObject *resultobj = 0;
27452 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27453 void *argp1 = 0 ;
27454 int res1 = 0 ;
27455 PyObject *swig_obj[1] ;
27456
27457 if (!args) SWIG_fail;
27458 swig_obj[0] = args;
27459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27460 if (!SWIG_IsOK(res1)) {
27461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27462 }
27463 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27464 {
27465 PyThreadState* __tstate = wxPyBeginAllowThreads();
27466 delete arg1;
27467
27468 wxPyEndAllowThreads(__tstate);
27469 if (PyErr_Occurred()) SWIG_fail;
27470 }
27471 resultobj = SWIG_Py_Void();
27472 return resultobj;
27473 fail:
27474 return NULL;
27475 }
27476
27477
27478 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27479 PyObject *resultobj = 0;
27480 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27481 PyObject *arg2 = (PyObject *) 0 ;
27482 void *argp1 = 0 ;
27483 int res1 = 0 ;
27484 PyObject * obj0 = 0 ;
27485 PyObject * obj1 = 0 ;
27486 char * kwnames[] = {
27487 (char *) "self",(char *) "self", NULL
27488 };
27489
27490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27492 if (!SWIG_IsOK(res1)) {
27493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27494 }
27495 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27496 arg2 = obj1;
27497 {
27498 PyThreadState* __tstate = wxPyBeginAllowThreads();
27499 (arg1)->SetSelf(arg2);
27500 wxPyEndAllowThreads(__tstate);
27501 if (PyErr_Occurred()) SWIG_fail;
27502 }
27503 resultobj = SWIG_Py_Void();
27504 return resultobj;
27505 fail:
27506 return NULL;
27507 }
27508
27509
27510 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27511 PyObject *resultobj = 0;
27512 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27513 PyObject *result = 0 ;
27514 void *argp1 = 0 ;
27515 int res1 = 0 ;
27516 PyObject *swig_obj[1] ;
27517
27518 if (!args) SWIG_fail;
27519 swig_obj[0] = args;
27520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27521 if (!SWIG_IsOK(res1)) {
27522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27523 }
27524 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27525 {
27526 PyThreadState* __tstate = wxPyBeginAllowThreads();
27527 result = (PyObject *)(arg1)->GetSelf();
27528 wxPyEndAllowThreads(__tstate);
27529 if (PyErr_Occurred()) SWIG_fail;
27530 }
27531 resultobj = result;
27532 return resultobj;
27533 fail:
27534 return NULL;
27535 }
27536
27537
27538 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27539 PyObject *obj;
27540 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27541 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27542 return SWIG_Py_Void();
27543 }
27544
27545 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27546 return SWIG_Python_InitShadowInstance(args);
27547 }
27548
27549 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27550 PyObject *resultobj = 0;
27551 wxWindow *arg1 = (wxWindow *) 0 ;
27552 wxDateTime *arg2 = 0 ;
27553 wxEventType arg3 ;
27554 wxDateEvent *result = 0 ;
27555 void *argp1 = 0 ;
27556 int res1 = 0 ;
27557 void *argp2 = 0 ;
27558 int res2 = 0 ;
27559 int val3 ;
27560 int ecode3 = 0 ;
27561 PyObject * obj0 = 0 ;
27562 PyObject * obj1 = 0 ;
27563 PyObject * obj2 = 0 ;
27564 char * kwnames[] = {
27565 (char *) "win",(char *) "dt",(char *) "type", NULL
27566 };
27567
27568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27570 if (!SWIG_IsOK(res1)) {
27571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27572 }
27573 arg1 = reinterpret_cast< wxWindow * >(argp1);
27574 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27575 if (!SWIG_IsOK(res2)) {
27576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27577 }
27578 if (!argp2) {
27579 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27580 }
27581 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27582 ecode3 = SWIG_AsVal_int(obj2, &val3);
27583 if (!SWIG_IsOK(ecode3)) {
27584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27585 }
27586 arg3 = static_cast< wxEventType >(val3);
27587 {
27588 PyThreadState* __tstate = wxPyBeginAllowThreads();
27589 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27590 wxPyEndAllowThreads(__tstate);
27591 if (PyErr_Occurred()) SWIG_fail;
27592 }
27593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27594 return resultobj;
27595 fail:
27596 return NULL;
27597 }
27598
27599
27600 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27601 PyObject *resultobj = 0;
27602 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27603 wxDateTime *result = 0 ;
27604 void *argp1 = 0 ;
27605 int res1 = 0 ;
27606 PyObject *swig_obj[1] ;
27607
27608 if (!args) SWIG_fail;
27609 swig_obj[0] = args;
27610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27611 if (!SWIG_IsOK(res1)) {
27612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27613 }
27614 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27615 {
27616 PyThreadState* __tstate = wxPyBeginAllowThreads();
27617 {
27618 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27619 result = (wxDateTime *) &_result_ref;
27620 }
27621 wxPyEndAllowThreads(__tstate);
27622 if (PyErr_Occurred()) SWIG_fail;
27623 }
27624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27625 return resultobj;
27626 fail:
27627 return NULL;
27628 }
27629
27630
27631 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27632 PyObject *resultobj = 0;
27633 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27634 wxDateTime *arg2 = 0 ;
27635 void *argp1 = 0 ;
27636 int res1 = 0 ;
27637 void *argp2 = 0 ;
27638 int res2 = 0 ;
27639 PyObject * obj0 = 0 ;
27640 PyObject * obj1 = 0 ;
27641 char * kwnames[] = {
27642 (char *) "self",(char *) "date", NULL
27643 };
27644
27645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27647 if (!SWIG_IsOK(res1)) {
27648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27649 }
27650 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27651 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27652 if (!SWIG_IsOK(res2)) {
27653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27654 }
27655 if (!argp2) {
27656 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27657 }
27658 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27659 {
27660 PyThreadState* __tstate = wxPyBeginAllowThreads();
27661 (arg1)->SetDate((wxDateTime const &)*arg2);
27662 wxPyEndAllowThreads(__tstate);
27663 if (PyErr_Occurred()) SWIG_fail;
27664 }
27665 resultobj = SWIG_Py_Void();
27666 return resultobj;
27667 fail:
27668 return NULL;
27669 }
27670
27671
27672 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27673 PyObject *obj;
27674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27675 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27676 return SWIG_Py_Void();
27677 }
27678
27679 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27680 return SWIG_Python_InitShadowInstance(args);
27681 }
27682
27683 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27684 PyObject *resultobj = 0;
27685 wxPyApp *result = 0 ;
27686
27687 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27688 {
27689 PyThreadState* __tstate = wxPyBeginAllowThreads();
27690 result = (wxPyApp *)new_wxPyApp();
27691 wxPyEndAllowThreads(__tstate);
27692 if (PyErr_Occurred()) SWIG_fail;
27693 }
27694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27695 return resultobj;
27696 fail:
27697 return NULL;
27698 }
27699
27700
27701 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27702 PyObject *resultobj = 0;
27703 wxPyApp *arg1 = (wxPyApp *) 0 ;
27704 void *argp1 = 0 ;
27705 int res1 = 0 ;
27706 PyObject *swig_obj[1] ;
27707
27708 if (!args) SWIG_fail;
27709 swig_obj[0] = args;
27710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27711 if (!SWIG_IsOK(res1)) {
27712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27713 }
27714 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27715 {
27716 PyThreadState* __tstate = wxPyBeginAllowThreads();
27717 delete arg1;
27718
27719 wxPyEndAllowThreads(__tstate);
27720 if (PyErr_Occurred()) SWIG_fail;
27721 }
27722 resultobj = SWIG_Py_Void();
27723 return resultobj;
27724 fail:
27725 return NULL;
27726 }
27727
27728
27729 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27730 PyObject *resultobj = 0;
27731 wxPyApp *arg1 = (wxPyApp *) 0 ;
27732 PyObject *arg2 = (PyObject *) 0 ;
27733 PyObject *arg3 = (PyObject *) 0 ;
27734 bool arg4 ;
27735 void *argp1 = 0 ;
27736 int res1 = 0 ;
27737 bool val4 ;
27738 int ecode4 = 0 ;
27739 PyObject * obj0 = 0 ;
27740 PyObject * obj1 = 0 ;
27741 PyObject * obj2 = 0 ;
27742 PyObject * obj3 = 0 ;
27743 char * kwnames[] = {
27744 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27745 };
27746
27747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27749 if (!SWIG_IsOK(res1)) {
27750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27751 }
27752 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27753 arg2 = obj1;
27754 arg3 = obj2;
27755 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27756 if (!SWIG_IsOK(ecode4)) {
27757 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27758 }
27759 arg4 = static_cast< bool >(val4);
27760 {
27761 PyThreadState* __tstate = wxPyBeginAllowThreads();
27762 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27763 wxPyEndAllowThreads(__tstate);
27764 if (PyErr_Occurred()) SWIG_fail;
27765 }
27766 resultobj = SWIG_Py_Void();
27767 return resultobj;
27768 fail:
27769 return NULL;
27770 }
27771
27772
27773 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27774 PyObject *resultobj = 0;
27775 wxPyApp *arg1 = (wxPyApp *) 0 ;
27776 wxString result;
27777 void *argp1 = 0 ;
27778 int res1 = 0 ;
27779 PyObject *swig_obj[1] ;
27780
27781 if (!args) SWIG_fail;
27782 swig_obj[0] = args;
27783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27784 if (!SWIG_IsOK(res1)) {
27785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27786 }
27787 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27788 {
27789 PyThreadState* __tstate = wxPyBeginAllowThreads();
27790 result = ((wxPyApp const *)arg1)->GetAppName();
27791 wxPyEndAllowThreads(__tstate);
27792 if (PyErr_Occurred()) SWIG_fail;
27793 }
27794 {
27795 #if wxUSE_UNICODE
27796 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27797 #else
27798 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27799 #endif
27800 }
27801 return resultobj;
27802 fail:
27803 return NULL;
27804 }
27805
27806
27807 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27808 PyObject *resultobj = 0;
27809 wxPyApp *arg1 = (wxPyApp *) 0 ;
27810 wxString *arg2 = 0 ;
27811 void *argp1 = 0 ;
27812 int res1 = 0 ;
27813 bool temp2 = false ;
27814 PyObject * obj0 = 0 ;
27815 PyObject * obj1 = 0 ;
27816 char * kwnames[] = {
27817 (char *) "self",(char *) "name", NULL
27818 };
27819
27820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27822 if (!SWIG_IsOK(res1)) {
27823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27824 }
27825 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27826 {
27827 arg2 = wxString_in_helper(obj1);
27828 if (arg2 == NULL) SWIG_fail;
27829 temp2 = true;
27830 }
27831 {
27832 PyThreadState* __tstate = wxPyBeginAllowThreads();
27833 (arg1)->SetAppName((wxString const &)*arg2);
27834 wxPyEndAllowThreads(__tstate);
27835 if (PyErr_Occurred()) SWIG_fail;
27836 }
27837 resultobj = SWIG_Py_Void();
27838 {
27839 if (temp2)
27840 delete arg2;
27841 }
27842 return resultobj;
27843 fail:
27844 {
27845 if (temp2)
27846 delete arg2;
27847 }
27848 return NULL;
27849 }
27850
27851
27852 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27853 PyObject *resultobj = 0;
27854 wxPyApp *arg1 = (wxPyApp *) 0 ;
27855 wxString result;
27856 void *argp1 = 0 ;
27857 int res1 = 0 ;
27858 PyObject *swig_obj[1] ;
27859
27860 if (!args) SWIG_fail;
27861 swig_obj[0] = args;
27862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27863 if (!SWIG_IsOK(res1)) {
27864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27865 }
27866 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27867 {
27868 PyThreadState* __tstate = wxPyBeginAllowThreads();
27869 result = ((wxPyApp const *)arg1)->GetClassName();
27870 wxPyEndAllowThreads(__tstate);
27871 if (PyErr_Occurred()) SWIG_fail;
27872 }
27873 {
27874 #if wxUSE_UNICODE
27875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27876 #else
27877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27878 #endif
27879 }
27880 return resultobj;
27881 fail:
27882 return NULL;
27883 }
27884
27885
27886 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27887 PyObject *resultobj = 0;
27888 wxPyApp *arg1 = (wxPyApp *) 0 ;
27889 wxString *arg2 = 0 ;
27890 void *argp1 = 0 ;
27891 int res1 = 0 ;
27892 bool temp2 = false ;
27893 PyObject * obj0 = 0 ;
27894 PyObject * obj1 = 0 ;
27895 char * kwnames[] = {
27896 (char *) "self",(char *) "name", NULL
27897 };
27898
27899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27901 if (!SWIG_IsOK(res1)) {
27902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27903 }
27904 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27905 {
27906 arg2 = wxString_in_helper(obj1);
27907 if (arg2 == NULL) SWIG_fail;
27908 temp2 = true;
27909 }
27910 {
27911 PyThreadState* __tstate = wxPyBeginAllowThreads();
27912 (arg1)->SetClassName((wxString const &)*arg2);
27913 wxPyEndAllowThreads(__tstate);
27914 if (PyErr_Occurred()) SWIG_fail;
27915 }
27916 resultobj = SWIG_Py_Void();
27917 {
27918 if (temp2)
27919 delete arg2;
27920 }
27921 return resultobj;
27922 fail:
27923 {
27924 if (temp2)
27925 delete arg2;
27926 }
27927 return NULL;
27928 }
27929
27930
27931 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27932 PyObject *resultobj = 0;
27933 wxPyApp *arg1 = (wxPyApp *) 0 ;
27934 wxString *result = 0 ;
27935 void *argp1 = 0 ;
27936 int res1 = 0 ;
27937 PyObject *swig_obj[1] ;
27938
27939 if (!args) SWIG_fail;
27940 swig_obj[0] = args;
27941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27942 if (!SWIG_IsOK(res1)) {
27943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27944 }
27945 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27946 {
27947 PyThreadState* __tstate = wxPyBeginAllowThreads();
27948 {
27949 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27950 result = (wxString *) &_result_ref;
27951 }
27952 wxPyEndAllowThreads(__tstate);
27953 if (PyErr_Occurred()) SWIG_fail;
27954 }
27955 {
27956 #if wxUSE_UNICODE
27957 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27958 #else
27959 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27960 #endif
27961 }
27962 return resultobj;
27963 fail:
27964 return NULL;
27965 }
27966
27967
27968 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27969 PyObject *resultobj = 0;
27970 wxPyApp *arg1 = (wxPyApp *) 0 ;
27971 wxString *arg2 = 0 ;
27972 void *argp1 = 0 ;
27973 int res1 = 0 ;
27974 bool temp2 = false ;
27975 PyObject * obj0 = 0 ;
27976 PyObject * obj1 = 0 ;
27977 char * kwnames[] = {
27978 (char *) "self",(char *) "name", NULL
27979 };
27980
27981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27983 if (!SWIG_IsOK(res1)) {
27984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27985 }
27986 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27987 {
27988 arg2 = wxString_in_helper(obj1);
27989 if (arg2 == NULL) SWIG_fail;
27990 temp2 = true;
27991 }
27992 {
27993 PyThreadState* __tstate = wxPyBeginAllowThreads();
27994 (arg1)->SetVendorName((wxString const &)*arg2);
27995 wxPyEndAllowThreads(__tstate);
27996 if (PyErr_Occurred()) SWIG_fail;
27997 }
27998 resultobj = SWIG_Py_Void();
27999 {
28000 if (temp2)
28001 delete arg2;
28002 }
28003 return resultobj;
28004 fail:
28005 {
28006 if (temp2)
28007 delete arg2;
28008 }
28009 return NULL;
28010 }
28011
28012
28013 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28014 PyObject *resultobj = 0;
28015 wxPyApp *arg1 = (wxPyApp *) 0 ;
28016 wxAppTraits *result = 0 ;
28017 void *argp1 = 0 ;
28018 int res1 = 0 ;
28019 PyObject *swig_obj[1] ;
28020
28021 if (!args) SWIG_fail;
28022 swig_obj[0] = args;
28023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28024 if (!SWIG_IsOK(res1)) {
28025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
28026 }
28027 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28028 {
28029 PyThreadState* __tstate = wxPyBeginAllowThreads();
28030 result = (wxAppTraits *)(arg1)->GetTraits();
28031 wxPyEndAllowThreads(__tstate);
28032 if (PyErr_Occurred()) SWIG_fail;
28033 }
28034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
28035 return resultobj;
28036 fail:
28037 return NULL;
28038 }
28039
28040
28041 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28042 PyObject *resultobj = 0;
28043 wxPyApp *arg1 = (wxPyApp *) 0 ;
28044 void *argp1 = 0 ;
28045 int res1 = 0 ;
28046 PyObject *swig_obj[1] ;
28047
28048 if (!args) SWIG_fail;
28049 swig_obj[0] = args;
28050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28051 if (!SWIG_IsOK(res1)) {
28052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28053 }
28054 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28055 {
28056 PyThreadState* __tstate = wxPyBeginAllowThreads();
28057 (arg1)->ProcessPendingEvents();
28058 wxPyEndAllowThreads(__tstate);
28059 if (PyErr_Occurred()) SWIG_fail;
28060 }
28061 resultobj = SWIG_Py_Void();
28062 return resultobj;
28063 fail:
28064 return NULL;
28065 }
28066
28067
28068 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28069 PyObject *resultobj = 0;
28070 wxPyApp *arg1 = (wxPyApp *) 0 ;
28071 bool arg2 = (bool) false ;
28072 bool result;
28073 void *argp1 = 0 ;
28074 int res1 = 0 ;
28075 bool val2 ;
28076 int ecode2 = 0 ;
28077 PyObject * obj0 = 0 ;
28078 PyObject * obj1 = 0 ;
28079 char * kwnames[] = {
28080 (char *) "self",(char *) "onlyIfNeeded", NULL
28081 };
28082
28083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
28084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28085 if (!SWIG_IsOK(res1)) {
28086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
28087 }
28088 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28089 if (obj1) {
28090 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28091 if (!SWIG_IsOK(ecode2)) {
28092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
28093 }
28094 arg2 = static_cast< bool >(val2);
28095 }
28096 {
28097 PyThreadState* __tstate = wxPyBeginAllowThreads();
28098 result = (bool)(arg1)->Yield(arg2);
28099 wxPyEndAllowThreads(__tstate);
28100 if (PyErr_Occurred()) SWIG_fail;
28101 }
28102 {
28103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28104 }
28105 return resultobj;
28106 fail:
28107 return NULL;
28108 }
28109
28110
28111 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28112 PyObject *resultobj = 0;
28113 wxPyApp *arg1 = (wxPyApp *) 0 ;
28114 void *argp1 = 0 ;
28115 int res1 = 0 ;
28116 PyObject *swig_obj[1] ;
28117
28118 if (!args) SWIG_fail;
28119 swig_obj[0] = args;
28120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28121 if (!SWIG_IsOK(res1)) {
28122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28123 }
28124 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28125 {
28126 PyThreadState* __tstate = wxPyBeginAllowThreads();
28127 (arg1)->WakeUpIdle();
28128 wxPyEndAllowThreads(__tstate);
28129 if (PyErr_Occurred()) SWIG_fail;
28130 }
28131 resultobj = SWIG_Py_Void();
28132 return resultobj;
28133 fail:
28134 return NULL;
28135 }
28136
28137
28138 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28139 PyObject *resultobj = 0;
28140 bool result;
28141
28142 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
28143 {
28144 PyThreadState* __tstate = wxPyBeginAllowThreads();
28145 result = (bool)wxPyApp::IsMainLoopRunning();
28146 wxPyEndAllowThreads(__tstate);
28147 if (PyErr_Occurred()) SWIG_fail;
28148 }
28149 {
28150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28151 }
28152 return resultobj;
28153 fail:
28154 return NULL;
28155 }
28156
28157
28158 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28159 PyObject *resultobj = 0;
28160 wxPyApp *arg1 = (wxPyApp *) 0 ;
28161 int result;
28162 void *argp1 = 0 ;
28163 int res1 = 0 ;
28164 PyObject *swig_obj[1] ;
28165
28166 if (!args) SWIG_fail;
28167 swig_obj[0] = args;
28168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28169 if (!SWIG_IsOK(res1)) {
28170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28171 }
28172 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28173 {
28174 PyThreadState* __tstate = wxPyBeginAllowThreads();
28175 result = (int)(arg1)->MainLoop();
28176 wxPyEndAllowThreads(__tstate);
28177 if (PyErr_Occurred()) SWIG_fail;
28178 }
28179 resultobj = SWIG_From_int(static_cast< int >(result));
28180 return resultobj;
28181 fail:
28182 return NULL;
28183 }
28184
28185
28186 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28187 PyObject *resultobj = 0;
28188 wxPyApp *arg1 = (wxPyApp *) 0 ;
28189 void *argp1 = 0 ;
28190 int res1 = 0 ;
28191 PyObject *swig_obj[1] ;
28192
28193 if (!args) SWIG_fail;
28194 swig_obj[0] = args;
28195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28196 if (!SWIG_IsOK(res1)) {
28197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
28198 }
28199 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28200 {
28201 PyThreadState* __tstate = wxPyBeginAllowThreads();
28202 (arg1)->Exit();
28203 wxPyEndAllowThreads(__tstate);
28204 if (PyErr_Occurred()) SWIG_fail;
28205 }
28206 resultobj = SWIG_Py_Void();
28207 return resultobj;
28208 fail:
28209 return NULL;
28210 }
28211
28212
28213 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28214 PyObject *resultobj = 0;
28215 wxPyApp *arg1 = (wxPyApp *) 0 ;
28216 wxLayoutDirection result;
28217 void *argp1 = 0 ;
28218 int res1 = 0 ;
28219 PyObject *swig_obj[1] ;
28220
28221 if (!args) SWIG_fail;
28222 swig_obj[0] = args;
28223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28224 if (!SWIG_IsOK(res1)) {
28225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28226 }
28227 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28228 {
28229 PyThreadState* __tstate = wxPyBeginAllowThreads();
28230 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
28231 wxPyEndAllowThreads(__tstate);
28232 if (PyErr_Occurred()) SWIG_fail;
28233 }
28234 resultobj = SWIG_From_int(static_cast< int >(result));
28235 return resultobj;
28236 fail:
28237 return NULL;
28238 }
28239
28240
28241 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28242 PyObject *resultobj = 0;
28243 wxPyApp *arg1 = (wxPyApp *) 0 ;
28244 void *argp1 = 0 ;
28245 int res1 = 0 ;
28246 PyObject *swig_obj[1] ;
28247
28248 if (!args) SWIG_fail;
28249 swig_obj[0] = args;
28250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28251 if (!SWIG_IsOK(res1)) {
28252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28253 }
28254 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28255 {
28256 PyThreadState* __tstate = wxPyBeginAllowThreads();
28257 (arg1)->ExitMainLoop();
28258 wxPyEndAllowThreads(__tstate);
28259 if (PyErr_Occurred()) SWIG_fail;
28260 }
28261 resultobj = SWIG_Py_Void();
28262 return resultobj;
28263 fail:
28264 return NULL;
28265 }
28266
28267
28268 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28269 PyObject *resultobj = 0;
28270 wxPyApp *arg1 = (wxPyApp *) 0 ;
28271 bool result;
28272 void *argp1 = 0 ;
28273 int res1 = 0 ;
28274 PyObject *swig_obj[1] ;
28275
28276 if (!args) SWIG_fail;
28277 swig_obj[0] = args;
28278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28279 if (!SWIG_IsOK(res1)) {
28280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
28281 }
28282 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28283 {
28284 PyThreadState* __tstate = wxPyBeginAllowThreads();
28285 result = (bool)(arg1)->Pending();
28286 wxPyEndAllowThreads(__tstate);
28287 if (PyErr_Occurred()) SWIG_fail;
28288 }
28289 {
28290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28291 }
28292 return resultobj;
28293 fail:
28294 return NULL;
28295 }
28296
28297
28298 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28299 PyObject *resultobj = 0;
28300 wxPyApp *arg1 = (wxPyApp *) 0 ;
28301 bool result;
28302 void *argp1 = 0 ;
28303 int res1 = 0 ;
28304 PyObject *swig_obj[1] ;
28305
28306 if (!args) SWIG_fail;
28307 swig_obj[0] = args;
28308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28309 if (!SWIG_IsOK(res1)) {
28310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
28311 }
28312 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28313 {
28314 PyThreadState* __tstate = wxPyBeginAllowThreads();
28315 result = (bool)(arg1)->Dispatch();
28316 wxPyEndAllowThreads(__tstate);
28317 if (PyErr_Occurred()) SWIG_fail;
28318 }
28319 {
28320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28321 }
28322 return resultobj;
28323 fail:
28324 return NULL;
28325 }
28326
28327
28328 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28329 PyObject *resultobj = 0;
28330 wxPyApp *arg1 = (wxPyApp *) 0 ;
28331 bool result;
28332 void *argp1 = 0 ;
28333 int res1 = 0 ;
28334 PyObject *swig_obj[1] ;
28335
28336 if (!args) SWIG_fail;
28337 swig_obj[0] = args;
28338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28339 if (!SWIG_IsOK(res1)) {
28340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28341 }
28342 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28343 {
28344 PyThreadState* __tstate = wxPyBeginAllowThreads();
28345 result = (bool)(arg1)->ProcessIdle();
28346 wxPyEndAllowThreads(__tstate);
28347 if (PyErr_Occurred()) SWIG_fail;
28348 }
28349 {
28350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28351 }
28352 return resultobj;
28353 fail:
28354 return NULL;
28355 }
28356
28357
28358 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28359 PyObject *resultobj = 0;
28360 wxPyApp *arg1 = (wxPyApp *) 0 ;
28361 wxWindow *arg2 = (wxWindow *) 0 ;
28362 wxIdleEvent *arg3 = 0 ;
28363 bool result;
28364 void *argp1 = 0 ;
28365 int res1 = 0 ;
28366 void *argp2 = 0 ;
28367 int res2 = 0 ;
28368 void *argp3 = 0 ;
28369 int res3 = 0 ;
28370 PyObject * obj0 = 0 ;
28371 PyObject * obj1 = 0 ;
28372 PyObject * obj2 = 0 ;
28373 char * kwnames[] = {
28374 (char *) "self",(char *) "win",(char *) "event", NULL
28375 };
28376
28377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28379 if (!SWIG_IsOK(res1)) {
28380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28381 }
28382 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28383 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28384 if (!SWIG_IsOK(res2)) {
28385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
28386 }
28387 arg2 = reinterpret_cast< wxWindow * >(argp2);
28388 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
28389 if (!SWIG_IsOK(res3)) {
28390 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28391 }
28392 if (!argp3) {
28393 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28394 }
28395 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
28396 {
28397 PyThreadState* __tstate = wxPyBeginAllowThreads();
28398 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
28399 wxPyEndAllowThreads(__tstate);
28400 if (PyErr_Occurred()) SWIG_fail;
28401 }
28402 {
28403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28404 }
28405 return resultobj;
28406 fail:
28407 return NULL;
28408 }
28409
28410
28411 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28412 PyObject *resultobj = 0;
28413 wxPyApp *arg1 = (wxPyApp *) 0 ;
28414 bool result;
28415 void *argp1 = 0 ;
28416 int res1 = 0 ;
28417 PyObject *swig_obj[1] ;
28418
28419 if (!args) SWIG_fail;
28420 swig_obj[0] = args;
28421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28422 if (!SWIG_IsOK(res1)) {
28423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28424 }
28425 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28426 {
28427 PyThreadState* __tstate = wxPyBeginAllowThreads();
28428 result = (bool)((wxPyApp const *)arg1)->IsActive();
28429 wxPyEndAllowThreads(__tstate);
28430 if (PyErr_Occurred()) SWIG_fail;
28431 }
28432 {
28433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28434 }
28435 return resultobj;
28436 fail:
28437 return NULL;
28438 }
28439
28440
28441 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28442 PyObject *resultobj = 0;
28443 wxPyApp *arg1 = (wxPyApp *) 0 ;
28444 wxWindow *arg2 = (wxWindow *) 0 ;
28445 void *argp1 = 0 ;
28446 int res1 = 0 ;
28447 void *argp2 = 0 ;
28448 int res2 = 0 ;
28449 PyObject * obj0 = 0 ;
28450 PyObject * obj1 = 0 ;
28451 char * kwnames[] = {
28452 (char *) "self",(char *) "win", NULL
28453 };
28454
28455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28457 if (!SWIG_IsOK(res1)) {
28458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28459 }
28460 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28461 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28462 if (!SWIG_IsOK(res2)) {
28463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28464 }
28465 arg2 = reinterpret_cast< wxWindow * >(argp2);
28466 {
28467 PyThreadState* __tstate = wxPyBeginAllowThreads();
28468 (arg1)->SetTopWindow(arg2);
28469 wxPyEndAllowThreads(__tstate);
28470 if (PyErr_Occurred()) SWIG_fail;
28471 }
28472 resultobj = SWIG_Py_Void();
28473 return resultobj;
28474 fail:
28475 return NULL;
28476 }
28477
28478
28479 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28480 PyObject *resultobj = 0;
28481 wxPyApp *arg1 = (wxPyApp *) 0 ;
28482 wxWindow *result = 0 ;
28483 void *argp1 = 0 ;
28484 int res1 = 0 ;
28485 PyObject *swig_obj[1] ;
28486
28487 if (!args) SWIG_fail;
28488 swig_obj[0] = args;
28489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28490 if (!SWIG_IsOK(res1)) {
28491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28492 }
28493 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28494 {
28495 PyThreadState* __tstate = wxPyBeginAllowThreads();
28496 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28497 wxPyEndAllowThreads(__tstate);
28498 if (PyErr_Occurred()) SWIG_fail;
28499 }
28500 {
28501 resultobj = wxPyMake_wxObject(result, (bool)0);
28502 }
28503 return resultobj;
28504 fail:
28505 return NULL;
28506 }
28507
28508
28509 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28510 PyObject *resultobj = 0;
28511 wxPyApp *arg1 = (wxPyApp *) 0 ;
28512 bool arg2 ;
28513 void *argp1 = 0 ;
28514 int res1 = 0 ;
28515 bool val2 ;
28516 int ecode2 = 0 ;
28517 PyObject * obj0 = 0 ;
28518 PyObject * obj1 = 0 ;
28519 char * kwnames[] = {
28520 (char *) "self",(char *) "flag", NULL
28521 };
28522
28523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28525 if (!SWIG_IsOK(res1)) {
28526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28527 }
28528 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28529 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28530 if (!SWIG_IsOK(ecode2)) {
28531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28532 }
28533 arg2 = static_cast< bool >(val2);
28534 {
28535 PyThreadState* __tstate = wxPyBeginAllowThreads();
28536 (arg1)->SetExitOnFrameDelete(arg2);
28537 wxPyEndAllowThreads(__tstate);
28538 if (PyErr_Occurred()) SWIG_fail;
28539 }
28540 resultobj = SWIG_Py_Void();
28541 return resultobj;
28542 fail:
28543 return NULL;
28544 }
28545
28546
28547 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28548 PyObject *resultobj = 0;
28549 wxPyApp *arg1 = (wxPyApp *) 0 ;
28550 bool result;
28551 void *argp1 = 0 ;
28552 int res1 = 0 ;
28553 PyObject *swig_obj[1] ;
28554
28555 if (!args) SWIG_fail;
28556 swig_obj[0] = args;
28557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28558 if (!SWIG_IsOK(res1)) {
28559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28560 }
28561 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28562 {
28563 PyThreadState* __tstate = wxPyBeginAllowThreads();
28564 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28565 wxPyEndAllowThreads(__tstate);
28566 if (PyErr_Occurred()) SWIG_fail;
28567 }
28568 {
28569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28570 }
28571 return resultobj;
28572 fail:
28573 return NULL;
28574 }
28575
28576
28577 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28578 PyObject *resultobj = 0;
28579 wxPyApp *arg1 = (wxPyApp *) 0 ;
28580 bool arg2 ;
28581 void *argp1 = 0 ;
28582 int res1 = 0 ;
28583 bool val2 ;
28584 int ecode2 = 0 ;
28585 PyObject * obj0 = 0 ;
28586 PyObject * obj1 = 0 ;
28587 char * kwnames[] = {
28588 (char *) "self",(char *) "flag", NULL
28589 };
28590
28591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28593 if (!SWIG_IsOK(res1)) {
28594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28595 }
28596 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28597 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28598 if (!SWIG_IsOK(ecode2)) {
28599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28600 }
28601 arg2 = static_cast< bool >(val2);
28602 {
28603 PyThreadState* __tstate = wxPyBeginAllowThreads();
28604 (arg1)->SetUseBestVisual(arg2);
28605 wxPyEndAllowThreads(__tstate);
28606 if (PyErr_Occurred()) SWIG_fail;
28607 }
28608 resultobj = SWIG_Py_Void();
28609 return resultobj;
28610 fail:
28611 return NULL;
28612 }
28613
28614
28615 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28616 PyObject *resultobj = 0;
28617 wxPyApp *arg1 = (wxPyApp *) 0 ;
28618 bool result;
28619 void *argp1 = 0 ;
28620 int res1 = 0 ;
28621 PyObject *swig_obj[1] ;
28622
28623 if (!args) SWIG_fail;
28624 swig_obj[0] = args;
28625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28626 if (!SWIG_IsOK(res1)) {
28627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28628 }
28629 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28630 {
28631 PyThreadState* __tstate = wxPyBeginAllowThreads();
28632 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28633 wxPyEndAllowThreads(__tstate);
28634 if (PyErr_Occurred()) SWIG_fail;
28635 }
28636 {
28637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28638 }
28639 return resultobj;
28640 fail:
28641 return NULL;
28642 }
28643
28644
28645 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28646 PyObject *resultobj = 0;
28647 wxPyApp *arg1 = (wxPyApp *) 0 ;
28648 int arg2 ;
28649 void *argp1 = 0 ;
28650 int res1 = 0 ;
28651 int val2 ;
28652 int ecode2 = 0 ;
28653 PyObject * obj0 = 0 ;
28654 PyObject * obj1 = 0 ;
28655 char * kwnames[] = {
28656 (char *) "self",(char *) "mode", NULL
28657 };
28658
28659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28661 if (!SWIG_IsOK(res1)) {
28662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28663 }
28664 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28665 ecode2 = SWIG_AsVal_int(obj1, &val2);
28666 if (!SWIG_IsOK(ecode2)) {
28667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28668 }
28669 arg2 = static_cast< int >(val2);
28670 {
28671 PyThreadState* __tstate = wxPyBeginAllowThreads();
28672 (arg1)->SetPrintMode(arg2);
28673 wxPyEndAllowThreads(__tstate);
28674 if (PyErr_Occurred()) SWIG_fail;
28675 }
28676 resultobj = SWIG_Py_Void();
28677 return resultobj;
28678 fail:
28679 return NULL;
28680 }
28681
28682
28683 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28684 PyObject *resultobj = 0;
28685 wxPyApp *arg1 = (wxPyApp *) 0 ;
28686 int result;
28687 void *argp1 = 0 ;
28688 int res1 = 0 ;
28689 PyObject *swig_obj[1] ;
28690
28691 if (!args) SWIG_fail;
28692 swig_obj[0] = args;
28693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28694 if (!SWIG_IsOK(res1)) {
28695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28696 }
28697 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28698 {
28699 PyThreadState* __tstate = wxPyBeginAllowThreads();
28700 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28701 wxPyEndAllowThreads(__tstate);
28702 if (PyErr_Occurred()) SWIG_fail;
28703 }
28704 resultobj = SWIG_From_int(static_cast< int >(result));
28705 return resultobj;
28706 fail:
28707 return NULL;
28708 }
28709
28710
28711 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28712 PyObject *resultobj = 0;
28713 wxPyApp *arg1 = (wxPyApp *) 0 ;
28714 int arg2 ;
28715 void *argp1 = 0 ;
28716 int res1 = 0 ;
28717 int val2 ;
28718 int ecode2 = 0 ;
28719 PyObject * obj0 = 0 ;
28720 PyObject * obj1 = 0 ;
28721 char * kwnames[] = {
28722 (char *) "self",(char *) "mode", NULL
28723 };
28724
28725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28727 if (!SWIG_IsOK(res1)) {
28728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28729 }
28730 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28731 ecode2 = SWIG_AsVal_int(obj1, &val2);
28732 if (!SWIG_IsOK(ecode2)) {
28733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28734 }
28735 arg2 = static_cast< int >(val2);
28736 {
28737 PyThreadState* __tstate = wxPyBeginAllowThreads();
28738 (arg1)->SetAssertMode(arg2);
28739 wxPyEndAllowThreads(__tstate);
28740 if (PyErr_Occurred()) SWIG_fail;
28741 }
28742 resultobj = SWIG_Py_Void();
28743 return resultobj;
28744 fail:
28745 return NULL;
28746 }
28747
28748
28749 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28750 PyObject *resultobj = 0;
28751 wxPyApp *arg1 = (wxPyApp *) 0 ;
28752 int result;
28753 void *argp1 = 0 ;
28754 int res1 = 0 ;
28755 PyObject *swig_obj[1] ;
28756
28757 if (!args) SWIG_fail;
28758 swig_obj[0] = args;
28759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28760 if (!SWIG_IsOK(res1)) {
28761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28762 }
28763 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28764 {
28765 PyThreadState* __tstate = wxPyBeginAllowThreads();
28766 result = (int)(arg1)->GetAssertMode();
28767 wxPyEndAllowThreads(__tstate);
28768 if (PyErr_Occurred()) SWIG_fail;
28769 }
28770 resultobj = SWIG_From_int(static_cast< int >(result));
28771 return resultobj;
28772 fail:
28773 return NULL;
28774 }
28775
28776
28777 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28778 PyObject *resultobj = 0;
28779 bool result;
28780
28781 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28785 wxPyEndAllowThreads(__tstate);
28786 if (PyErr_Occurred()) SWIG_fail;
28787 }
28788 {
28789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28790 }
28791 return resultobj;
28792 fail:
28793 return NULL;
28794 }
28795
28796
28797 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28798 PyObject *resultobj = 0;
28799 long result;
28800
28801 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28802 {
28803 PyThreadState* __tstate = wxPyBeginAllowThreads();
28804 result = (long)wxPyApp::GetMacAboutMenuItemId();
28805 wxPyEndAllowThreads(__tstate);
28806 if (PyErr_Occurred()) SWIG_fail;
28807 }
28808 resultobj = SWIG_From_long(static_cast< long >(result));
28809 return resultobj;
28810 fail:
28811 return NULL;
28812 }
28813
28814
28815 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28816 PyObject *resultobj = 0;
28817 long result;
28818
28819 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28820 {
28821 PyThreadState* __tstate = wxPyBeginAllowThreads();
28822 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28823 wxPyEndAllowThreads(__tstate);
28824 if (PyErr_Occurred()) SWIG_fail;
28825 }
28826 resultobj = SWIG_From_long(static_cast< long >(result));
28827 return resultobj;
28828 fail:
28829 return NULL;
28830 }
28831
28832
28833 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28834 PyObject *resultobj = 0;
28835 long result;
28836
28837 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28838 {
28839 PyThreadState* __tstate = wxPyBeginAllowThreads();
28840 result = (long)wxPyApp::GetMacExitMenuItemId();
28841 wxPyEndAllowThreads(__tstate);
28842 if (PyErr_Occurred()) SWIG_fail;
28843 }
28844 resultobj = SWIG_From_long(static_cast< long >(result));
28845 return resultobj;
28846 fail:
28847 return NULL;
28848 }
28849
28850
28851 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28852 PyObject *resultobj = 0;
28853 wxString result;
28854
28855 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28856 {
28857 PyThreadState* __tstate = wxPyBeginAllowThreads();
28858 result = wxPyApp::GetMacHelpMenuTitleName();
28859 wxPyEndAllowThreads(__tstate);
28860 if (PyErr_Occurred()) SWIG_fail;
28861 }
28862 {
28863 #if wxUSE_UNICODE
28864 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28865 #else
28866 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28867 #endif
28868 }
28869 return resultobj;
28870 fail:
28871 return NULL;
28872 }
28873
28874
28875 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28876 PyObject *resultobj = 0;
28877 bool arg1 ;
28878 bool val1 ;
28879 int ecode1 = 0 ;
28880 PyObject * obj0 = 0 ;
28881 char * kwnames[] = {
28882 (char *) "val", NULL
28883 };
28884
28885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28886 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28887 if (!SWIG_IsOK(ecode1)) {
28888 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28889 }
28890 arg1 = static_cast< bool >(val1);
28891 {
28892 PyThreadState* __tstate = wxPyBeginAllowThreads();
28893 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28894 wxPyEndAllowThreads(__tstate);
28895 if (PyErr_Occurred()) SWIG_fail;
28896 }
28897 resultobj = SWIG_Py_Void();
28898 return resultobj;
28899 fail:
28900 return NULL;
28901 }
28902
28903
28904 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28905 PyObject *resultobj = 0;
28906 long arg1 ;
28907 long val1 ;
28908 int ecode1 = 0 ;
28909 PyObject * obj0 = 0 ;
28910 char * kwnames[] = {
28911 (char *) "val", NULL
28912 };
28913
28914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28915 ecode1 = SWIG_AsVal_long(obj0, &val1);
28916 if (!SWIG_IsOK(ecode1)) {
28917 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28918 }
28919 arg1 = static_cast< long >(val1);
28920 {
28921 PyThreadState* __tstate = wxPyBeginAllowThreads();
28922 wxPyApp::SetMacAboutMenuItemId(arg1);
28923 wxPyEndAllowThreads(__tstate);
28924 if (PyErr_Occurred()) SWIG_fail;
28925 }
28926 resultobj = SWIG_Py_Void();
28927 return resultobj;
28928 fail:
28929 return NULL;
28930 }
28931
28932
28933 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28934 PyObject *resultobj = 0;
28935 long arg1 ;
28936 long val1 ;
28937 int ecode1 = 0 ;
28938 PyObject * obj0 = 0 ;
28939 char * kwnames[] = {
28940 (char *) "val", NULL
28941 };
28942
28943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28944 ecode1 = SWIG_AsVal_long(obj0, &val1);
28945 if (!SWIG_IsOK(ecode1)) {
28946 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28947 }
28948 arg1 = static_cast< long >(val1);
28949 {
28950 PyThreadState* __tstate = wxPyBeginAllowThreads();
28951 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28952 wxPyEndAllowThreads(__tstate);
28953 if (PyErr_Occurred()) SWIG_fail;
28954 }
28955 resultobj = SWIG_Py_Void();
28956 return resultobj;
28957 fail:
28958 return NULL;
28959 }
28960
28961
28962 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28963 PyObject *resultobj = 0;
28964 long arg1 ;
28965 long val1 ;
28966 int ecode1 = 0 ;
28967 PyObject * obj0 = 0 ;
28968 char * kwnames[] = {
28969 (char *) "val", NULL
28970 };
28971
28972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28973 ecode1 = SWIG_AsVal_long(obj0, &val1);
28974 if (!SWIG_IsOK(ecode1)) {
28975 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28976 }
28977 arg1 = static_cast< long >(val1);
28978 {
28979 PyThreadState* __tstate = wxPyBeginAllowThreads();
28980 wxPyApp::SetMacExitMenuItemId(arg1);
28981 wxPyEndAllowThreads(__tstate);
28982 if (PyErr_Occurred()) SWIG_fail;
28983 }
28984 resultobj = SWIG_Py_Void();
28985 return resultobj;
28986 fail:
28987 return NULL;
28988 }
28989
28990
28991 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28992 PyObject *resultobj = 0;
28993 wxString *arg1 = 0 ;
28994 bool temp1 = false ;
28995 PyObject * obj0 = 0 ;
28996 char * kwnames[] = {
28997 (char *) "val", NULL
28998 };
28999
29000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
29001 {
29002 arg1 = wxString_in_helper(obj0);
29003 if (arg1 == NULL) SWIG_fail;
29004 temp1 = true;
29005 }
29006 {
29007 PyThreadState* __tstate = wxPyBeginAllowThreads();
29008 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
29009 wxPyEndAllowThreads(__tstate);
29010 if (PyErr_Occurred()) SWIG_fail;
29011 }
29012 resultobj = SWIG_Py_Void();
29013 {
29014 if (temp1)
29015 delete arg1;
29016 }
29017 return resultobj;
29018 fail:
29019 {
29020 if (temp1)
29021 delete arg1;
29022 }
29023 return NULL;
29024 }
29025
29026
29027 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29028 PyObject *resultobj = 0;
29029 wxPyApp *arg1 = (wxPyApp *) 0 ;
29030 void *argp1 = 0 ;
29031 int res1 = 0 ;
29032 PyObject *swig_obj[1] ;
29033
29034 if (!args) SWIG_fail;
29035 swig_obj[0] = args;
29036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29037 if (!SWIG_IsOK(res1)) {
29038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29039 }
29040 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29041 {
29042 PyThreadState* __tstate = wxPyBeginAllowThreads();
29043 (arg1)->_BootstrapApp();
29044 wxPyEndAllowThreads(__tstate);
29045 if (PyErr_Occurred()) SWIG_fail;
29046 }
29047 resultobj = SWIG_Py_Void();
29048 return resultobj;
29049 fail:
29050 return NULL;
29051 }
29052
29053
29054 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29055 PyObject *resultobj = 0;
29056 int result;
29057
29058 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
29059 {
29060 PyThreadState* __tstate = wxPyBeginAllowThreads();
29061 result = (int)wxPyApp::GetComCtl32Version();
29062 wxPyEndAllowThreads(__tstate);
29063 if (PyErr_Occurred()) SWIG_fail;
29064 }
29065 resultobj = SWIG_From_int(static_cast< int >(result));
29066 return resultobj;
29067 fail:
29068 return NULL;
29069 }
29070
29071
29072 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29073 PyObject *resultobj = 0;
29074 bool result;
29075
29076 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
29077 {
29078 PyThreadState* __tstate = wxPyBeginAllowThreads();
29079 result = (bool)wxPyApp_IsDisplayAvailable();
29080 wxPyEndAllowThreads(__tstate);
29081 if (PyErr_Occurred()) SWIG_fail;
29082 }
29083 {
29084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29085 }
29086 return resultobj;
29087 fail:
29088 return NULL;
29089 }
29090
29091
29092 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29093 PyObject *obj;
29094 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29095 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
29096 return SWIG_Py_Void();
29097 }
29098
29099 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29100 return SWIG_Python_InitShadowInstance(args);
29101 }
29102
29103 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29104 PyObject *resultobj = 0;
29105
29106 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
29107 {
29108 PyThreadState* __tstate = wxPyBeginAllowThreads();
29109 wxExit();
29110 wxPyEndAllowThreads(__tstate);
29111 if (PyErr_Occurred()) SWIG_fail;
29112 }
29113 resultobj = SWIG_Py_Void();
29114 return resultobj;
29115 fail:
29116 return NULL;
29117 }
29118
29119
29120 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29121 PyObject *resultobj = 0;
29122 bool result;
29123
29124 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
29125 {
29126 PyThreadState* __tstate = wxPyBeginAllowThreads();
29127 result = (bool)wxYield();
29128 wxPyEndAllowThreads(__tstate);
29129 if (PyErr_Occurred()) SWIG_fail;
29130 }
29131 {
29132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29133 }
29134 return resultobj;
29135 fail:
29136 return NULL;
29137 }
29138
29139
29140 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29141 PyObject *resultobj = 0;
29142 bool result;
29143
29144 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
29145 {
29146 PyThreadState* __tstate = wxPyBeginAllowThreads();
29147 result = (bool)wxYieldIfNeeded();
29148 wxPyEndAllowThreads(__tstate);
29149 if (PyErr_Occurred()) SWIG_fail;
29150 }
29151 {
29152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29153 }
29154 return resultobj;
29155 fail:
29156 return NULL;
29157 }
29158
29159
29160 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29161 PyObject *resultobj = 0;
29162 wxWindow *arg1 = (wxWindow *) NULL ;
29163 bool arg2 = (bool) false ;
29164 bool result;
29165 void *argp1 = 0 ;
29166 int res1 = 0 ;
29167 bool val2 ;
29168 int ecode2 = 0 ;
29169 PyObject * obj0 = 0 ;
29170 PyObject * obj1 = 0 ;
29171 char * kwnames[] = {
29172 (char *) "win",(char *) "onlyIfNeeded", NULL
29173 };
29174
29175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
29176 if (obj0) {
29177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29178 if (!SWIG_IsOK(res1)) {
29179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
29180 }
29181 arg1 = reinterpret_cast< wxWindow * >(argp1);
29182 }
29183 if (obj1) {
29184 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29185 if (!SWIG_IsOK(ecode2)) {
29186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
29187 }
29188 arg2 = static_cast< bool >(val2);
29189 }
29190 {
29191 PyThreadState* __tstate = wxPyBeginAllowThreads();
29192 result = (bool)wxSafeYield(arg1,arg2);
29193 wxPyEndAllowThreads(__tstate);
29194 if (PyErr_Occurred()) SWIG_fail;
29195 }
29196 {
29197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29198 }
29199 return resultobj;
29200 fail:
29201 return NULL;
29202 }
29203
29204
29205 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29206 PyObject *resultobj = 0;
29207
29208 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
29209 {
29210 PyThreadState* __tstate = wxPyBeginAllowThreads();
29211 wxWakeUpIdle();
29212 wxPyEndAllowThreads(__tstate);
29213 if (PyErr_Occurred()) SWIG_fail;
29214 }
29215 resultobj = SWIG_Py_Void();
29216 return resultobj;
29217 fail:
29218 return NULL;
29219 }
29220
29221
29222 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29223 PyObject *resultobj = 0;
29224 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
29225 wxEvent *arg2 = 0 ;
29226 void *argp1 = 0 ;
29227 int res1 = 0 ;
29228 void *argp2 = 0 ;
29229 int res2 = 0 ;
29230 PyObject * obj0 = 0 ;
29231 PyObject * obj1 = 0 ;
29232 char * kwnames[] = {
29233 (char *) "dest",(char *) "event", NULL
29234 };
29235
29236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
29238 if (!SWIG_IsOK(res1)) {
29239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
29240 }
29241 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
29242 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
29243 if (!SWIG_IsOK(res2)) {
29244 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29245 }
29246 if (!argp2) {
29247 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29248 }
29249 arg2 = reinterpret_cast< wxEvent * >(argp2);
29250 {
29251 PyThreadState* __tstate = wxPyBeginAllowThreads();
29252 wxPostEvent(arg1,*arg2);
29253 wxPyEndAllowThreads(__tstate);
29254 if (PyErr_Occurred()) SWIG_fail;
29255 }
29256 resultobj = SWIG_Py_Void();
29257 return resultobj;
29258 fail:
29259 return NULL;
29260 }
29261
29262
29263 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29264 PyObject *resultobj = 0;
29265
29266 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
29267 {
29268 PyThreadState* __tstate = wxPyBeginAllowThreads();
29269 wxApp_CleanUp();
29270 wxPyEndAllowThreads(__tstate);
29271 if (PyErr_Occurred()) SWIG_fail;
29272 }
29273 resultobj = SWIG_Py_Void();
29274 return resultobj;
29275 fail:
29276 return NULL;
29277 }
29278
29279
29280 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29281 PyObject *resultobj = 0;
29282 wxPyApp *result = 0 ;
29283
29284 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
29285 {
29286 PyThreadState* __tstate = wxPyBeginAllowThreads();
29287 result = (wxPyApp *)wxPyGetApp();
29288 wxPyEndAllowThreads(__tstate);
29289 if (PyErr_Occurred()) SWIG_fail;
29290 }
29291 {
29292 resultobj = wxPyMake_wxObject(result, 0);
29293 }
29294 return resultobj;
29295 fail:
29296 return NULL;
29297 }
29298
29299
29300 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29301 PyObject *resultobj = 0;
29302 char *arg1 = (char *) 0 ;
29303 int res1 ;
29304 char *buf1 = 0 ;
29305 int alloc1 = 0 ;
29306 PyObject * obj0 = 0 ;
29307 char * kwnames[] = {
29308 (char *) "encoding", NULL
29309 };
29310
29311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
29312 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
29313 if (!SWIG_IsOK(res1)) {
29314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
29315 }
29316 arg1 = buf1;
29317 {
29318 PyThreadState* __tstate = wxPyBeginAllowThreads();
29319 wxSetDefaultPyEncoding((char const *)arg1);
29320 wxPyEndAllowThreads(__tstate);
29321 if (PyErr_Occurred()) SWIG_fail;
29322 }
29323 resultobj = SWIG_Py_Void();
29324 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29325 return resultobj;
29326 fail:
29327 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29328 return NULL;
29329 }
29330
29331
29332 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29333 PyObject *resultobj = 0;
29334 char *result = 0 ;
29335
29336 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
29337 {
29338 PyThreadState* __tstate = wxPyBeginAllowThreads();
29339 result = (char *)wxGetDefaultPyEncoding();
29340 wxPyEndAllowThreads(__tstate);
29341 if (PyErr_Occurred()) SWIG_fail;
29342 }
29343 resultobj = SWIG_FromCharPtr(result);
29344 return resultobj;
29345 fail:
29346 return NULL;
29347 }
29348
29349
29350 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29351 PyObject *resultobj = 0;
29352 wxEventLoop *result = 0 ;
29353
29354 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
29355 {
29356 PyThreadState* __tstate = wxPyBeginAllowThreads();
29357 result = (wxEventLoop *)new wxEventLoop();
29358 wxPyEndAllowThreads(__tstate);
29359 if (PyErr_Occurred()) SWIG_fail;
29360 }
29361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
29362 return resultobj;
29363 fail:
29364 return NULL;
29365 }
29366
29367
29368 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29369 PyObject *resultobj = 0;
29370 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29371 void *argp1 = 0 ;
29372 int res1 = 0 ;
29373 PyObject *swig_obj[1] ;
29374
29375 if (!args) SWIG_fail;
29376 swig_obj[0] = args;
29377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
29378 if (!SWIG_IsOK(res1)) {
29379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29380 }
29381 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29382 {
29383 PyThreadState* __tstate = wxPyBeginAllowThreads();
29384 delete arg1;
29385
29386 wxPyEndAllowThreads(__tstate);
29387 if (PyErr_Occurred()) SWIG_fail;
29388 }
29389 resultobj = SWIG_Py_Void();
29390 return resultobj;
29391 fail:
29392 return NULL;
29393 }
29394
29395
29396 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29397 PyObject *resultobj = 0;
29398 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29399 int result;
29400 void *argp1 = 0 ;
29401 int res1 = 0 ;
29402 PyObject *swig_obj[1] ;
29403
29404 if (!args) SWIG_fail;
29405 swig_obj[0] = args;
29406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29407 if (!SWIG_IsOK(res1)) {
29408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29409 }
29410 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29411 {
29412 PyThreadState* __tstate = wxPyBeginAllowThreads();
29413 result = (int)(arg1)->Run();
29414 wxPyEndAllowThreads(__tstate);
29415 if (PyErr_Occurred()) SWIG_fail;
29416 }
29417 resultobj = SWIG_From_int(static_cast< int >(result));
29418 return resultobj;
29419 fail:
29420 return NULL;
29421 }
29422
29423
29424 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29425 PyObject *resultobj = 0;
29426 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29427 int arg2 = (int) 0 ;
29428 void *argp1 = 0 ;
29429 int res1 = 0 ;
29430 int val2 ;
29431 int ecode2 = 0 ;
29432 PyObject * obj0 = 0 ;
29433 PyObject * obj1 = 0 ;
29434 char * kwnames[] = {
29435 (char *) "self",(char *) "rc", NULL
29436 };
29437
29438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
29439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29440 if (!SWIG_IsOK(res1)) {
29441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29442 }
29443 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29444 if (obj1) {
29445 ecode2 = SWIG_AsVal_int(obj1, &val2);
29446 if (!SWIG_IsOK(ecode2)) {
29447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29448 }
29449 arg2 = static_cast< int >(val2);
29450 }
29451 {
29452 PyThreadState* __tstate = wxPyBeginAllowThreads();
29453 (arg1)->Exit(arg2);
29454 wxPyEndAllowThreads(__tstate);
29455 if (PyErr_Occurred()) SWIG_fail;
29456 }
29457 resultobj = SWIG_Py_Void();
29458 return resultobj;
29459 fail:
29460 return NULL;
29461 }
29462
29463
29464 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29465 PyObject *resultobj = 0;
29466 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29467 bool result;
29468 void *argp1 = 0 ;
29469 int res1 = 0 ;
29470 PyObject *swig_obj[1] ;
29471
29472 if (!args) SWIG_fail;
29473 swig_obj[0] = args;
29474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29475 if (!SWIG_IsOK(res1)) {
29476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29477 }
29478 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29479 {
29480 PyThreadState* __tstate = wxPyBeginAllowThreads();
29481 result = (bool)((wxEventLoop const *)arg1)->Pending();
29482 wxPyEndAllowThreads(__tstate);
29483 if (PyErr_Occurred()) SWIG_fail;
29484 }
29485 {
29486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29487 }
29488 return resultobj;
29489 fail:
29490 return NULL;
29491 }
29492
29493
29494 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29495 PyObject *resultobj = 0;
29496 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29497 bool result;
29498 void *argp1 = 0 ;
29499 int res1 = 0 ;
29500 PyObject *swig_obj[1] ;
29501
29502 if (!args) SWIG_fail;
29503 swig_obj[0] = args;
29504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29505 if (!SWIG_IsOK(res1)) {
29506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29507 }
29508 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29509 {
29510 PyThreadState* __tstate = wxPyBeginAllowThreads();
29511 result = (bool)(arg1)->Dispatch();
29512 wxPyEndAllowThreads(__tstate);
29513 if (PyErr_Occurred()) SWIG_fail;
29514 }
29515 {
29516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29517 }
29518 return resultobj;
29519 fail:
29520 return NULL;
29521 }
29522
29523
29524 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29525 PyObject *resultobj = 0;
29526 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29527 bool result;
29528 void *argp1 = 0 ;
29529 int res1 = 0 ;
29530 PyObject *swig_obj[1] ;
29531
29532 if (!args) SWIG_fail;
29533 swig_obj[0] = args;
29534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29535 if (!SWIG_IsOK(res1)) {
29536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29537 }
29538 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29539 {
29540 PyThreadState* __tstate = wxPyBeginAllowThreads();
29541 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29542 wxPyEndAllowThreads(__tstate);
29543 if (PyErr_Occurred()) SWIG_fail;
29544 }
29545 {
29546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29547 }
29548 return resultobj;
29549 fail:
29550 return NULL;
29551 }
29552
29553
29554 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29555 PyObject *resultobj = 0;
29556 wxEventLoop *result = 0 ;
29557
29558 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29559 {
29560 PyThreadState* __tstate = wxPyBeginAllowThreads();
29561 result = (wxEventLoop *)wxEventLoop::GetActive();
29562 wxPyEndAllowThreads(__tstate);
29563 if (PyErr_Occurred()) SWIG_fail;
29564 }
29565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29566 return resultobj;
29567 fail:
29568 return NULL;
29569 }
29570
29571
29572 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29573 PyObject *resultobj = 0;
29574 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29575 void *argp1 = 0 ;
29576 int res1 = 0 ;
29577 PyObject * obj0 = 0 ;
29578 char * kwnames[] = {
29579 (char *) "loop", NULL
29580 };
29581
29582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29584 if (!SWIG_IsOK(res1)) {
29585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29586 }
29587 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29588 {
29589 PyThreadState* __tstate = wxPyBeginAllowThreads();
29590 wxEventLoop::SetActive(arg1);
29591 wxPyEndAllowThreads(__tstate);
29592 if (PyErr_Occurred()) SWIG_fail;
29593 }
29594 resultobj = SWIG_Py_Void();
29595 return resultobj;
29596 fail:
29597 return NULL;
29598 }
29599
29600
29601 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29602 PyObject *obj;
29603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29604 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29605 return SWIG_Py_Void();
29606 }
29607
29608 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29609 return SWIG_Python_InitShadowInstance(args);
29610 }
29611
29612 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29613 PyObject *resultobj = 0;
29614 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29615 wxEventLoopActivator *result = 0 ;
29616 void *argp1 = 0 ;
29617 int res1 = 0 ;
29618 PyObject * obj0 = 0 ;
29619 char * kwnames[] = {
29620 (char *) "evtLoop", NULL
29621 };
29622
29623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29625 if (!SWIG_IsOK(res1)) {
29626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29627 }
29628 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29629 {
29630 PyThreadState* __tstate = wxPyBeginAllowThreads();
29631 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29632 wxPyEndAllowThreads(__tstate);
29633 if (PyErr_Occurred()) SWIG_fail;
29634 }
29635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29636 return resultobj;
29637 fail:
29638 return NULL;
29639 }
29640
29641
29642 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29643 PyObject *resultobj = 0;
29644 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29645 void *argp1 = 0 ;
29646 int res1 = 0 ;
29647 PyObject *swig_obj[1] ;
29648
29649 if (!args) SWIG_fail;
29650 swig_obj[0] = args;
29651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29652 if (!SWIG_IsOK(res1)) {
29653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29654 }
29655 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29656 {
29657 PyThreadState* __tstate = wxPyBeginAllowThreads();
29658 delete arg1;
29659
29660 wxPyEndAllowThreads(__tstate);
29661 if (PyErr_Occurred()) SWIG_fail;
29662 }
29663 resultobj = SWIG_Py_Void();
29664 return resultobj;
29665 fail:
29666 return NULL;
29667 }
29668
29669
29670 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29671 PyObject *obj;
29672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29673 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29674 return SWIG_Py_Void();
29675 }
29676
29677 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29678 return SWIG_Python_InitShadowInstance(args);
29679 }
29680
29681 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29682 PyObject *resultobj = 0;
29683 int arg1 = (int) 0 ;
29684 int arg2 = (int) 0 ;
29685 int arg3 = (int) 0 ;
29686 wxAcceleratorEntry *result = 0 ;
29687 int val1 ;
29688 int ecode1 = 0 ;
29689 int val2 ;
29690 int ecode2 = 0 ;
29691 int val3 ;
29692 int ecode3 = 0 ;
29693 PyObject * obj0 = 0 ;
29694 PyObject * obj1 = 0 ;
29695 PyObject * obj2 = 0 ;
29696 char * kwnames[] = {
29697 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29698 };
29699
29700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29701 if (obj0) {
29702 ecode1 = SWIG_AsVal_int(obj0, &val1);
29703 if (!SWIG_IsOK(ecode1)) {
29704 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29705 }
29706 arg1 = static_cast< int >(val1);
29707 }
29708 if (obj1) {
29709 ecode2 = SWIG_AsVal_int(obj1, &val2);
29710 if (!SWIG_IsOK(ecode2)) {
29711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29712 }
29713 arg2 = static_cast< int >(val2);
29714 }
29715 if (obj2) {
29716 ecode3 = SWIG_AsVal_int(obj2, &val3);
29717 if (!SWIG_IsOK(ecode3)) {
29718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29719 }
29720 arg3 = static_cast< int >(val3);
29721 }
29722 {
29723 PyThreadState* __tstate = wxPyBeginAllowThreads();
29724 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29725 wxPyEndAllowThreads(__tstate);
29726 if (PyErr_Occurred()) SWIG_fail;
29727 }
29728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29729 return resultobj;
29730 fail:
29731 return NULL;
29732 }
29733
29734
29735 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29736 PyObject *resultobj = 0;
29737 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29738 void *argp1 = 0 ;
29739 int res1 = 0 ;
29740 PyObject *swig_obj[1] ;
29741
29742 if (!args) SWIG_fail;
29743 swig_obj[0] = args;
29744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29745 if (!SWIG_IsOK(res1)) {
29746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29747 }
29748 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29749 {
29750 PyThreadState* __tstate = wxPyBeginAllowThreads();
29751 delete arg1;
29752
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 resultobj = SWIG_Py_Void();
29757 return resultobj;
29758 fail:
29759 return NULL;
29760 }
29761
29762
29763 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29764 PyObject *resultobj = 0;
29765 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29766 int arg2 ;
29767 int arg3 ;
29768 int arg4 ;
29769 void *argp1 = 0 ;
29770 int res1 = 0 ;
29771 int val2 ;
29772 int ecode2 = 0 ;
29773 int val3 ;
29774 int ecode3 = 0 ;
29775 int val4 ;
29776 int ecode4 = 0 ;
29777 PyObject * obj0 = 0 ;
29778 PyObject * obj1 = 0 ;
29779 PyObject * obj2 = 0 ;
29780 PyObject * obj3 = 0 ;
29781 char * kwnames[] = {
29782 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29783 };
29784
29785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29787 if (!SWIG_IsOK(res1)) {
29788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29789 }
29790 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29791 ecode2 = SWIG_AsVal_int(obj1, &val2);
29792 if (!SWIG_IsOK(ecode2)) {
29793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29794 }
29795 arg2 = static_cast< int >(val2);
29796 ecode3 = SWIG_AsVal_int(obj2, &val3);
29797 if (!SWIG_IsOK(ecode3)) {
29798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29799 }
29800 arg3 = static_cast< int >(val3);
29801 ecode4 = SWIG_AsVal_int(obj3, &val4);
29802 if (!SWIG_IsOK(ecode4)) {
29803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29804 }
29805 arg4 = static_cast< int >(val4);
29806 {
29807 PyThreadState* __tstate = wxPyBeginAllowThreads();
29808 (arg1)->Set(arg2,arg3,arg4);
29809 wxPyEndAllowThreads(__tstate);
29810 if (PyErr_Occurred()) SWIG_fail;
29811 }
29812 resultobj = SWIG_Py_Void();
29813 return resultobj;
29814 fail:
29815 return NULL;
29816 }
29817
29818
29819 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29820 PyObject *resultobj = 0;
29821 wxString *arg1 = 0 ;
29822 wxAcceleratorEntry *result = 0 ;
29823 bool temp1 = false ;
29824 PyObject * obj0 = 0 ;
29825 char * kwnames[] = {
29826 (char *) "str", NULL
29827 };
29828
29829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29830 {
29831 arg1 = wxString_in_helper(obj0);
29832 if (arg1 == NULL) SWIG_fail;
29833 temp1 = true;
29834 }
29835 {
29836 PyThreadState* __tstate = wxPyBeginAllowThreads();
29837 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29838 wxPyEndAllowThreads(__tstate);
29839 if (PyErr_Occurred()) SWIG_fail;
29840 }
29841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29842 {
29843 if (temp1)
29844 delete arg1;
29845 }
29846 return resultobj;
29847 fail:
29848 {
29849 if (temp1)
29850 delete arg1;
29851 }
29852 return NULL;
29853 }
29854
29855
29856 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29857 PyObject *resultobj = 0;
29858 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29859 int result;
29860 void *argp1 = 0 ;
29861 int res1 = 0 ;
29862 PyObject *swig_obj[1] ;
29863
29864 if (!args) SWIG_fail;
29865 swig_obj[0] = args;
29866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29867 if (!SWIG_IsOK(res1)) {
29868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29869 }
29870 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29871 {
29872 PyThreadState* __tstate = wxPyBeginAllowThreads();
29873 result = (int)(arg1)->GetFlags();
29874 wxPyEndAllowThreads(__tstate);
29875 if (PyErr_Occurred()) SWIG_fail;
29876 }
29877 resultobj = SWIG_From_int(static_cast< int >(result));
29878 return resultobj;
29879 fail:
29880 return NULL;
29881 }
29882
29883
29884 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29885 PyObject *resultobj = 0;
29886 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29887 int result;
29888 void *argp1 = 0 ;
29889 int res1 = 0 ;
29890 PyObject *swig_obj[1] ;
29891
29892 if (!args) SWIG_fail;
29893 swig_obj[0] = args;
29894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29895 if (!SWIG_IsOK(res1)) {
29896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29897 }
29898 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29899 {
29900 PyThreadState* __tstate = wxPyBeginAllowThreads();
29901 result = (int)(arg1)->GetKeyCode();
29902 wxPyEndAllowThreads(__tstate);
29903 if (PyErr_Occurred()) SWIG_fail;
29904 }
29905 resultobj = SWIG_From_int(static_cast< int >(result));
29906 return resultobj;
29907 fail:
29908 return NULL;
29909 }
29910
29911
29912 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29913 PyObject *resultobj = 0;
29914 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29915 int result;
29916 void *argp1 = 0 ;
29917 int res1 = 0 ;
29918 PyObject *swig_obj[1] ;
29919
29920 if (!args) SWIG_fail;
29921 swig_obj[0] = args;
29922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29923 if (!SWIG_IsOK(res1)) {
29924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29925 }
29926 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29927 {
29928 PyThreadState* __tstate = wxPyBeginAllowThreads();
29929 result = (int)(arg1)->GetCommand();
29930 wxPyEndAllowThreads(__tstate);
29931 if (PyErr_Occurred()) SWIG_fail;
29932 }
29933 resultobj = SWIG_From_int(static_cast< int >(result));
29934 return resultobj;
29935 fail:
29936 return NULL;
29937 }
29938
29939
29940 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29941 PyObject *resultobj = 0;
29942 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29943 bool result;
29944 void *argp1 = 0 ;
29945 int res1 = 0 ;
29946 PyObject *swig_obj[1] ;
29947
29948 if (!args) SWIG_fail;
29949 swig_obj[0] = args;
29950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29951 if (!SWIG_IsOK(res1)) {
29952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29953 }
29954 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29955 {
29956 PyThreadState* __tstate = wxPyBeginAllowThreads();
29957 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
29958 wxPyEndAllowThreads(__tstate);
29959 if (PyErr_Occurred()) SWIG_fail;
29960 }
29961 {
29962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29963 }
29964 return resultobj;
29965 fail:
29966 return NULL;
29967 }
29968
29969
29970 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29971 PyObject *resultobj = 0;
29972 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29973 wxString result;
29974 void *argp1 = 0 ;
29975 int res1 = 0 ;
29976 PyObject *swig_obj[1] ;
29977
29978 if (!args) SWIG_fail;
29979 swig_obj[0] = args;
29980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29981 if (!SWIG_IsOK(res1)) {
29982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29983 }
29984 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29985 {
29986 PyThreadState* __tstate = wxPyBeginAllowThreads();
29987 result = ((wxAcceleratorEntry const *)arg1)->ToString();
29988 wxPyEndAllowThreads(__tstate);
29989 if (PyErr_Occurred()) SWIG_fail;
29990 }
29991 {
29992 #if wxUSE_UNICODE
29993 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29994 #else
29995 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29996 #endif
29997 }
29998 return resultobj;
29999 fail:
30000 return NULL;
30001 }
30002
30003
30004 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30005 PyObject *resultobj = 0;
30006 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30007 wxString *arg2 = 0 ;
30008 bool result;
30009 void *argp1 = 0 ;
30010 int res1 = 0 ;
30011 bool temp2 = false ;
30012 PyObject * obj0 = 0 ;
30013 PyObject * obj1 = 0 ;
30014 char * kwnames[] = {
30015 (char *) "self",(char *) "str", NULL
30016 };
30017
30018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
30019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30020 if (!SWIG_IsOK(res1)) {
30021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30022 }
30023 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30024 {
30025 arg2 = wxString_in_helper(obj1);
30026 if (arg2 == NULL) SWIG_fail;
30027 temp2 = true;
30028 }
30029 {
30030 PyThreadState* __tstate = wxPyBeginAllowThreads();
30031 result = (bool)(arg1)->FromString((wxString const &)*arg2);
30032 wxPyEndAllowThreads(__tstate);
30033 if (PyErr_Occurred()) SWIG_fail;
30034 }
30035 {
30036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30037 }
30038 {
30039 if (temp2)
30040 delete arg2;
30041 }
30042 return resultobj;
30043 fail:
30044 {
30045 if (temp2)
30046 delete arg2;
30047 }
30048 return NULL;
30049 }
30050
30051
30052 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30053 PyObject *obj;
30054 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30055 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
30056 return SWIG_Py_Void();
30057 }
30058
30059 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30060 return SWIG_Python_InitShadowInstance(args);
30061 }
30062
30063 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30064 PyObject *resultobj = 0;
30065 int arg1 ;
30066 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
30067 wxAcceleratorTable *result = 0 ;
30068 PyObject * obj0 = 0 ;
30069 char * kwnames[] = {
30070 (char *) "n", NULL
30071 };
30072
30073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
30074 {
30075 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
30076 if (arg2) arg1 = PyList_Size(obj0);
30077 else arg1 = 0;
30078 }
30079 {
30080 PyThreadState* __tstate = wxPyBeginAllowThreads();
30081 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
30082 wxPyEndAllowThreads(__tstate);
30083 if (PyErr_Occurred()) SWIG_fail;
30084 }
30085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
30086 return resultobj;
30087 fail:
30088 return NULL;
30089 }
30090
30091
30092 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30093 PyObject *resultobj = 0;
30094 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30095 void *argp1 = 0 ;
30096 int res1 = 0 ;
30097 PyObject *swig_obj[1] ;
30098
30099 if (!args) SWIG_fail;
30100 swig_obj[0] = args;
30101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
30102 if (!SWIG_IsOK(res1)) {
30103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
30104 }
30105 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30106 {
30107 PyThreadState* __tstate = wxPyBeginAllowThreads();
30108 delete arg1;
30109
30110 wxPyEndAllowThreads(__tstate);
30111 if (PyErr_Occurred()) SWIG_fail;
30112 }
30113 resultobj = SWIG_Py_Void();
30114 return resultobj;
30115 fail:
30116 return NULL;
30117 }
30118
30119
30120 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30121 PyObject *resultobj = 0;
30122 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30123 bool result;
30124 void *argp1 = 0 ;
30125 int res1 = 0 ;
30126 PyObject *swig_obj[1] ;
30127
30128 if (!args) SWIG_fail;
30129 swig_obj[0] = args;
30130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
30131 if (!SWIG_IsOK(res1)) {
30132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
30133 }
30134 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30135 {
30136 PyThreadState* __tstate = wxPyBeginAllowThreads();
30137 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
30138 wxPyEndAllowThreads(__tstate);
30139 if (PyErr_Occurred()) SWIG_fail;
30140 }
30141 {
30142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30143 }
30144 return resultobj;
30145 fail:
30146 return NULL;
30147 }
30148
30149
30150 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30151 PyObject *obj;
30152 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30153 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
30154 return SWIG_Py_Void();
30155 }
30156
30157 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30158 return SWIG_Python_InitShadowInstance(args);
30159 }
30160
30161 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
30162 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
30163 return 1;
30164 }
30165
30166
30167 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
30168 PyObject *pyobj = 0;
30169
30170 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
30171 return pyobj;
30172 }
30173
30174
30175 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30176 PyObject *resultobj = 0;
30177 wxString *arg1 = 0 ;
30178 wxAcceleratorEntry *result = 0 ;
30179 bool temp1 = false ;
30180 PyObject * obj0 = 0 ;
30181 char * kwnames[] = {
30182 (char *) "label", NULL
30183 };
30184
30185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
30186 {
30187 arg1 = wxString_in_helper(obj0);
30188 if (arg1 == NULL) SWIG_fail;
30189 temp1 = true;
30190 }
30191 {
30192 PyThreadState* __tstate = wxPyBeginAllowThreads();
30193 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
30194 wxPyEndAllowThreads(__tstate);
30195 if (PyErr_Occurred()) SWIG_fail;
30196 }
30197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30198 {
30199 if (temp1)
30200 delete arg1;
30201 }
30202 return resultobj;
30203 fail:
30204 {
30205 if (temp1)
30206 delete arg1;
30207 }
30208 return NULL;
30209 }
30210
30211
30212 SWIGINTERN int PanelNameStr_set(PyObject *) {
30213 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
30214 return 1;
30215 }
30216
30217
30218 SWIGINTERN PyObject *PanelNameStr_get(void) {
30219 PyObject *pyobj = 0;
30220
30221 {
30222 #if wxUSE_UNICODE
30223 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30224 #else
30225 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30226 #endif
30227 }
30228 return pyobj;
30229 }
30230
30231
30232 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30233 PyObject *resultobj = 0;
30234 wxVisualAttributes *result = 0 ;
30235
30236 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
30237 {
30238 PyThreadState* __tstate = wxPyBeginAllowThreads();
30239 result = (wxVisualAttributes *)new_wxVisualAttributes();
30240 wxPyEndAllowThreads(__tstate);
30241 if (PyErr_Occurred()) SWIG_fail;
30242 }
30243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
30244 return resultobj;
30245 fail:
30246 return NULL;
30247 }
30248
30249
30250 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30251 PyObject *resultobj = 0;
30252 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30253 void *argp1 = 0 ;
30254 int res1 = 0 ;
30255 PyObject *swig_obj[1] ;
30256
30257 if (!args) SWIG_fail;
30258 swig_obj[0] = args;
30259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
30260 if (!SWIG_IsOK(res1)) {
30261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30262 }
30263 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30264 {
30265 PyThreadState* __tstate = wxPyBeginAllowThreads();
30266 delete_wxVisualAttributes(arg1);
30267
30268 wxPyEndAllowThreads(__tstate);
30269 if (PyErr_Occurred()) SWIG_fail;
30270 }
30271 resultobj = SWIG_Py_Void();
30272 return resultobj;
30273 fail:
30274 return NULL;
30275 }
30276
30277
30278 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30279 PyObject *resultobj = 0;
30280 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30281 wxFont *arg2 = (wxFont *) 0 ;
30282 void *argp1 = 0 ;
30283 int res1 = 0 ;
30284 void *argp2 = 0 ;
30285 int res2 = 0 ;
30286 PyObject *swig_obj[2] ;
30287
30288 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
30289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30290 if (!SWIG_IsOK(res1)) {
30291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30292 }
30293 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30294 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
30295 if (!SWIG_IsOK(res2)) {
30296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
30297 }
30298 arg2 = reinterpret_cast< wxFont * >(argp2);
30299 if (arg1) (arg1)->font = *arg2;
30300
30301 resultobj = SWIG_Py_Void();
30302 return resultobj;
30303 fail:
30304 return NULL;
30305 }
30306
30307
30308 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30309 PyObject *resultobj = 0;
30310 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30311 wxFont *result = 0 ;
30312 void *argp1 = 0 ;
30313 int res1 = 0 ;
30314 PyObject *swig_obj[1] ;
30315
30316 if (!args) SWIG_fail;
30317 swig_obj[0] = args;
30318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30319 if (!SWIG_IsOK(res1)) {
30320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30321 }
30322 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30323 result = (wxFont *)& ((arg1)->font);
30324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
30325 return resultobj;
30326 fail:
30327 return NULL;
30328 }
30329
30330
30331 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30332 PyObject *resultobj = 0;
30333 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30334 wxColour *arg2 = (wxColour *) 0 ;
30335 void *argp1 = 0 ;
30336 int res1 = 0 ;
30337 void *argp2 = 0 ;
30338 int res2 = 0 ;
30339 PyObject *swig_obj[2] ;
30340
30341 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
30342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30343 if (!SWIG_IsOK(res1)) {
30344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30345 }
30346 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30347 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30348 if (!SWIG_IsOK(res2)) {
30349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30350 }
30351 arg2 = reinterpret_cast< wxColour * >(argp2);
30352 if (arg1) (arg1)->colFg = *arg2;
30353
30354 resultobj = SWIG_Py_Void();
30355 return resultobj;
30356 fail:
30357 return NULL;
30358 }
30359
30360
30361 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30362 PyObject *resultobj = 0;
30363 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30364 wxColour *result = 0 ;
30365 void *argp1 = 0 ;
30366 int res1 = 0 ;
30367 PyObject *swig_obj[1] ;
30368
30369 if (!args) SWIG_fail;
30370 swig_obj[0] = args;
30371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30372 if (!SWIG_IsOK(res1)) {
30373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30374 }
30375 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30376 result = (wxColour *)& ((arg1)->colFg);
30377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30378 return resultobj;
30379 fail:
30380 return NULL;
30381 }
30382
30383
30384 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30385 PyObject *resultobj = 0;
30386 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30387 wxColour *arg2 = (wxColour *) 0 ;
30388 void *argp1 = 0 ;
30389 int res1 = 0 ;
30390 void *argp2 = 0 ;
30391 int res2 = 0 ;
30392 PyObject *swig_obj[2] ;
30393
30394 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
30395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30396 if (!SWIG_IsOK(res1)) {
30397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30398 }
30399 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30400 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30401 if (!SWIG_IsOK(res2)) {
30402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30403 }
30404 arg2 = reinterpret_cast< wxColour * >(argp2);
30405 if (arg1) (arg1)->colBg = *arg2;
30406
30407 resultobj = SWIG_Py_Void();
30408 return resultobj;
30409 fail:
30410 return NULL;
30411 }
30412
30413
30414 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30415 PyObject *resultobj = 0;
30416 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30417 wxColour *result = 0 ;
30418 void *argp1 = 0 ;
30419 int res1 = 0 ;
30420 PyObject *swig_obj[1] ;
30421
30422 if (!args) SWIG_fail;
30423 swig_obj[0] = args;
30424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30425 if (!SWIG_IsOK(res1)) {
30426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30427 }
30428 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30429 result = (wxColour *)& ((arg1)->colBg);
30430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30431 return resultobj;
30432 fail:
30433 return NULL;
30434 }
30435
30436
30437 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30438 PyObject *obj;
30439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30440 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30441 return SWIG_Py_Void();
30442 }
30443
30444 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30445 return SWIG_Python_InitShadowInstance(args);
30446 }
30447
30448 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30449 PyObject *resultobj = 0;
30450 wxWindow *arg1 = (wxWindow *) 0 ;
30451 int arg2 = (int) (int)-1 ;
30452 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30453 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30454 wxSize const &arg4_defvalue = wxDefaultSize ;
30455 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30456 long arg5 = (long) 0 ;
30457 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30458 wxString *arg6 = (wxString *) &arg6_defvalue ;
30459 wxWindow *result = 0 ;
30460 void *argp1 = 0 ;
30461 int res1 = 0 ;
30462 int val2 ;
30463 int ecode2 = 0 ;
30464 wxPoint temp3 ;
30465 wxSize temp4 ;
30466 long val5 ;
30467 int ecode5 = 0 ;
30468 bool temp6 = false ;
30469 PyObject * obj0 = 0 ;
30470 PyObject * obj1 = 0 ;
30471 PyObject * obj2 = 0 ;
30472 PyObject * obj3 = 0 ;
30473 PyObject * obj4 = 0 ;
30474 PyObject * obj5 = 0 ;
30475 char * kwnames[] = {
30476 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30477 };
30478
30479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30481 if (!SWIG_IsOK(res1)) {
30482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30483 }
30484 arg1 = reinterpret_cast< wxWindow * >(argp1);
30485 if (obj1) {
30486 ecode2 = SWIG_AsVal_int(obj1, &val2);
30487 if (!SWIG_IsOK(ecode2)) {
30488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30489 }
30490 arg2 = static_cast< int >(val2);
30491 }
30492 if (obj2) {
30493 {
30494 arg3 = &temp3;
30495 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30496 }
30497 }
30498 if (obj3) {
30499 {
30500 arg4 = &temp4;
30501 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30502 }
30503 }
30504 if (obj4) {
30505 ecode5 = SWIG_AsVal_long(obj4, &val5);
30506 if (!SWIG_IsOK(ecode5)) {
30507 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30508 }
30509 arg5 = static_cast< long >(val5);
30510 }
30511 if (obj5) {
30512 {
30513 arg6 = wxString_in_helper(obj5);
30514 if (arg6 == NULL) SWIG_fail;
30515 temp6 = true;
30516 }
30517 }
30518 {
30519 if (!wxPyCheckForApp()) SWIG_fail;
30520 PyThreadState* __tstate = wxPyBeginAllowThreads();
30521 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30522 wxPyEndAllowThreads(__tstate);
30523 if (PyErr_Occurred()) SWIG_fail;
30524 }
30525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30526 {
30527 if (temp6)
30528 delete arg6;
30529 }
30530 return resultobj;
30531 fail:
30532 {
30533 if (temp6)
30534 delete arg6;
30535 }
30536 return NULL;
30537 }
30538
30539
30540 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30541 PyObject *resultobj = 0;
30542 wxWindow *result = 0 ;
30543
30544 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30545 {
30546 if (!wxPyCheckForApp()) SWIG_fail;
30547 PyThreadState* __tstate = wxPyBeginAllowThreads();
30548 result = (wxWindow *)new wxWindow();
30549 wxPyEndAllowThreads(__tstate);
30550 if (PyErr_Occurred()) SWIG_fail;
30551 }
30552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30553 return resultobj;
30554 fail:
30555 return NULL;
30556 }
30557
30558
30559 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30560 PyObject *resultobj = 0;
30561 wxWindow *arg1 = (wxWindow *) 0 ;
30562 wxWindow *arg2 = (wxWindow *) 0 ;
30563 int arg3 = (int) (int)-1 ;
30564 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30565 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30566 wxSize const &arg5_defvalue = wxDefaultSize ;
30567 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30568 long arg6 = (long) 0 ;
30569 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30570 wxString *arg7 = (wxString *) &arg7_defvalue ;
30571 bool result;
30572 void *argp1 = 0 ;
30573 int res1 = 0 ;
30574 void *argp2 = 0 ;
30575 int res2 = 0 ;
30576 int val3 ;
30577 int ecode3 = 0 ;
30578 wxPoint temp4 ;
30579 wxSize temp5 ;
30580 long val6 ;
30581 int ecode6 = 0 ;
30582 bool temp7 = false ;
30583 PyObject * obj0 = 0 ;
30584 PyObject * obj1 = 0 ;
30585 PyObject * obj2 = 0 ;
30586 PyObject * obj3 = 0 ;
30587 PyObject * obj4 = 0 ;
30588 PyObject * obj5 = 0 ;
30589 PyObject * obj6 = 0 ;
30590 char * kwnames[] = {
30591 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30592 };
30593
30594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30596 if (!SWIG_IsOK(res1)) {
30597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30598 }
30599 arg1 = reinterpret_cast< wxWindow * >(argp1);
30600 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30601 if (!SWIG_IsOK(res2)) {
30602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30603 }
30604 arg2 = reinterpret_cast< wxWindow * >(argp2);
30605 if (obj2) {
30606 ecode3 = SWIG_AsVal_int(obj2, &val3);
30607 if (!SWIG_IsOK(ecode3)) {
30608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30609 }
30610 arg3 = static_cast< int >(val3);
30611 }
30612 if (obj3) {
30613 {
30614 arg4 = &temp4;
30615 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30616 }
30617 }
30618 if (obj4) {
30619 {
30620 arg5 = &temp5;
30621 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30622 }
30623 }
30624 if (obj5) {
30625 ecode6 = SWIG_AsVal_long(obj5, &val6);
30626 if (!SWIG_IsOK(ecode6)) {
30627 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30628 }
30629 arg6 = static_cast< long >(val6);
30630 }
30631 if (obj6) {
30632 {
30633 arg7 = wxString_in_helper(obj6);
30634 if (arg7 == NULL) SWIG_fail;
30635 temp7 = true;
30636 }
30637 }
30638 {
30639 PyThreadState* __tstate = wxPyBeginAllowThreads();
30640 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30641 wxPyEndAllowThreads(__tstate);
30642 if (PyErr_Occurred()) SWIG_fail;
30643 }
30644 {
30645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30646 }
30647 {
30648 if (temp7)
30649 delete arg7;
30650 }
30651 return resultobj;
30652 fail:
30653 {
30654 if (temp7)
30655 delete arg7;
30656 }
30657 return NULL;
30658 }
30659
30660
30661 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30662 PyObject *resultobj = 0;
30663 wxWindow *arg1 = (wxWindow *) 0 ;
30664 bool arg2 = (bool) false ;
30665 bool result;
30666 void *argp1 = 0 ;
30667 int res1 = 0 ;
30668 bool val2 ;
30669 int ecode2 = 0 ;
30670 PyObject * obj0 = 0 ;
30671 PyObject * obj1 = 0 ;
30672 char * kwnames[] = {
30673 (char *) "self",(char *) "force", NULL
30674 };
30675
30676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30678 if (!SWIG_IsOK(res1)) {
30679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30680 }
30681 arg1 = reinterpret_cast< wxWindow * >(argp1);
30682 if (obj1) {
30683 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30684 if (!SWIG_IsOK(ecode2)) {
30685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30686 }
30687 arg2 = static_cast< bool >(val2);
30688 }
30689 {
30690 PyThreadState* __tstate = wxPyBeginAllowThreads();
30691 result = (bool)(arg1)->Close(arg2);
30692 wxPyEndAllowThreads(__tstate);
30693 if (PyErr_Occurred()) SWIG_fail;
30694 }
30695 {
30696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30697 }
30698 return resultobj;
30699 fail:
30700 return NULL;
30701 }
30702
30703
30704 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30705 PyObject *resultobj = 0;
30706 wxWindow *arg1 = (wxWindow *) 0 ;
30707 bool result;
30708 void *argp1 = 0 ;
30709 int res1 = 0 ;
30710 PyObject *swig_obj[1] ;
30711
30712 if (!args) SWIG_fail;
30713 swig_obj[0] = args;
30714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30715 if (!SWIG_IsOK(res1)) {
30716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30717 }
30718 arg1 = reinterpret_cast< wxWindow * >(argp1);
30719 {
30720 PyThreadState* __tstate = wxPyBeginAllowThreads();
30721 result = (bool)(arg1)->Destroy();
30722 wxPyEndAllowThreads(__tstate);
30723 if (PyErr_Occurred()) SWIG_fail;
30724 }
30725 {
30726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30727 }
30728 return resultobj;
30729 fail:
30730 return NULL;
30731 }
30732
30733
30734 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30735 PyObject *resultobj = 0;
30736 wxWindow *arg1 = (wxWindow *) 0 ;
30737 bool result;
30738 void *argp1 = 0 ;
30739 int res1 = 0 ;
30740 PyObject *swig_obj[1] ;
30741
30742 if (!args) SWIG_fail;
30743 swig_obj[0] = args;
30744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30745 if (!SWIG_IsOK(res1)) {
30746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30747 }
30748 arg1 = reinterpret_cast< wxWindow * >(argp1);
30749 {
30750 PyThreadState* __tstate = wxPyBeginAllowThreads();
30751 result = (bool)(arg1)->DestroyChildren();
30752 wxPyEndAllowThreads(__tstate);
30753 if (PyErr_Occurred()) SWIG_fail;
30754 }
30755 {
30756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30757 }
30758 return resultobj;
30759 fail:
30760 return NULL;
30761 }
30762
30763
30764 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30765 PyObject *resultobj = 0;
30766 wxWindow *arg1 = (wxWindow *) 0 ;
30767 bool result;
30768 void *argp1 = 0 ;
30769 int res1 = 0 ;
30770 PyObject *swig_obj[1] ;
30771
30772 if (!args) SWIG_fail;
30773 swig_obj[0] = args;
30774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30775 if (!SWIG_IsOK(res1)) {
30776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30777 }
30778 arg1 = reinterpret_cast< wxWindow * >(argp1);
30779 {
30780 PyThreadState* __tstate = wxPyBeginAllowThreads();
30781 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30782 wxPyEndAllowThreads(__tstate);
30783 if (PyErr_Occurred()) SWIG_fail;
30784 }
30785 {
30786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30787 }
30788 return resultobj;
30789 fail:
30790 return NULL;
30791 }
30792
30793
30794 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30795 PyObject *resultobj = 0;
30796 wxWindow *arg1 = (wxWindow *) 0 ;
30797 wxString *arg2 = 0 ;
30798 void *argp1 = 0 ;
30799 int res1 = 0 ;
30800 bool temp2 = false ;
30801 PyObject * obj0 = 0 ;
30802 PyObject * obj1 = 0 ;
30803 char * kwnames[] = {
30804 (char *) "self",(char *) "label", NULL
30805 };
30806
30807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30809 if (!SWIG_IsOK(res1)) {
30810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30811 }
30812 arg1 = reinterpret_cast< wxWindow * >(argp1);
30813 {
30814 arg2 = wxString_in_helper(obj1);
30815 if (arg2 == NULL) SWIG_fail;
30816 temp2 = true;
30817 }
30818 {
30819 PyThreadState* __tstate = wxPyBeginAllowThreads();
30820 (arg1)->SetLabel((wxString const &)*arg2);
30821 wxPyEndAllowThreads(__tstate);
30822 if (PyErr_Occurred()) SWIG_fail;
30823 }
30824 resultobj = SWIG_Py_Void();
30825 {
30826 if (temp2)
30827 delete arg2;
30828 }
30829 return resultobj;
30830 fail:
30831 {
30832 if (temp2)
30833 delete arg2;
30834 }
30835 return NULL;
30836 }
30837
30838
30839 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30840 PyObject *resultobj = 0;
30841 wxWindow *arg1 = (wxWindow *) 0 ;
30842 wxString result;
30843 void *argp1 = 0 ;
30844 int res1 = 0 ;
30845 PyObject *swig_obj[1] ;
30846
30847 if (!args) SWIG_fail;
30848 swig_obj[0] = args;
30849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30850 if (!SWIG_IsOK(res1)) {
30851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30852 }
30853 arg1 = reinterpret_cast< wxWindow * >(argp1);
30854 {
30855 PyThreadState* __tstate = wxPyBeginAllowThreads();
30856 result = ((wxWindow const *)arg1)->GetLabel();
30857 wxPyEndAllowThreads(__tstate);
30858 if (PyErr_Occurred()) SWIG_fail;
30859 }
30860 {
30861 #if wxUSE_UNICODE
30862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30863 #else
30864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30865 #endif
30866 }
30867 return resultobj;
30868 fail:
30869 return NULL;
30870 }
30871
30872
30873 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30874 PyObject *resultobj = 0;
30875 wxWindow *arg1 = (wxWindow *) 0 ;
30876 wxString *arg2 = 0 ;
30877 void *argp1 = 0 ;
30878 int res1 = 0 ;
30879 bool temp2 = false ;
30880 PyObject * obj0 = 0 ;
30881 PyObject * obj1 = 0 ;
30882 char * kwnames[] = {
30883 (char *) "self",(char *) "name", NULL
30884 };
30885
30886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30888 if (!SWIG_IsOK(res1)) {
30889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30890 }
30891 arg1 = reinterpret_cast< wxWindow * >(argp1);
30892 {
30893 arg2 = wxString_in_helper(obj1);
30894 if (arg2 == NULL) SWIG_fail;
30895 temp2 = true;
30896 }
30897 {
30898 PyThreadState* __tstate = wxPyBeginAllowThreads();
30899 (arg1)->SetName((wxString const &)*arg2);
30900 wxPyEndAllowThreads(__tstate);
30901 if (PyErr_Occurred()) SWIG_fail;
30902 }
30903 resultobj = SWIG_Py_Void();
30904 {
30905 if (temp2)
30906 delete arg2;
30907 }
30908 return resultobj;
30909 fail:
30910 {
30911 if (temp2)
30912 delete arg2;
30913 }
30914 return NULL;
30915 }
30916
30917
30918 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30919 PyObject *resultobj = 0;
30920 wxWindow *arg1 = (wxWindow *) 0 ;
30921 wxString result;
30922 void *argp1 = 0 ;
30923 int res1 = 0 ;
30924 PyObject *swig_obj[1] ;
30925
30926 if (!args) SWIG_fail;
30927 swig_obj[0] = args;
30928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30929 if (!SWIG_IsOK(res1)) {
30930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30931 }
30932 arg1 = reinterpret_cast< wxWindow * >(argp1);
30933 {
30934 PyThreadState* __tstate = wxPyBeginAllowThreads();
30935 result = ((wxWindow const *)arg1)->GetName();
30936 wxPyEndAllowThreads(__tstate);
30937 if (PyErr_Occurred()) SWIG_fail;
30938 }
30939 {
30940 #if wxUSE_UNICODE
30941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30942 #else
30943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30944 #endif
30945 }
30946 return resultobj;
30947 fail:
30948 return NULL;
30949 }
30950
30951
30952 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30953 PyObject *resultobj = 0;
30954 wxWindow *arg1 = (wxWindow *) 0 ;
30955 wxWindowVariant arg2 ;
30956 void *argp1 = 0 ;
30957 int res1 = 0 ;
30958 int val2 ;
30959 int ecode2 = 0 ;
30960 PyObject * obj0 = 0 ;
30961 PyObject * obj1 = 0 ;
30962 char * kwnames[] = {
30963 (char *) "self",(char *) "variant", NULL
30964 };
30965
30966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30968 if (!SWIG_IsOK(res1)) {
30969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30970 }
30971 arg1 = reinterpret_cast< wxWindow * >(argp1);
30972 ecode2 = SWIG_AsVal_int(obj1, &val2);
30973 if (!SWIG_IsOK(ecode2)) {
30974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30975 }
30976 arg2 = static_cast< wxWindowVariant >(val2);
30977 {
30978 PyThreadState* __tstate = wxPyBeginAllowThreads();
30979 (arg1)->SetWindowVariant(arg2);
30980 wxPyEndAllowThreads(__tstate);
30981 if (PyErr_Occurred()) SWIG_fail;
30982 }
30983 resultobj = SWIG_Py_Void();
30984 return resultobj;
30985 fail:
30986 return NULL;
30987 }
30988
30989
30990 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30991 PyObject *resultobj = 0;
30992 wxWindow *arg1 = (wxWindow *) 0 ;
30993 wxWindowVariant result;
30994 void *argp1 = 0 ;
30995 int res1 = 0 ;
30996 PyObject *swig_obj[1] ;
30997
30998 if (!args) SWIG_fail;
30999 swig_obj[0] = args;
31000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31001 if (!SWIG_IsOK(res1)) {
31002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
31003 }
31004 arg1 = reinterpret_cast< wxWindow * >(argp1);
31005 {
31006 PyThreadState* __tstate = wxPyBeginAllowThreads();
31007 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
31008 wxPyEndAllowThreads(__tstate);
31009 if (PyErr_Occurred()) SWIG_fail;
31010 }
31011 resultobj = SWIG_From_int(static_cast< int >(result));
31012 return resultobj;
31013 fail:
31014 return NULL;
31015 }
31016
31017
31018 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31019 PyObject *resultobj = 0;
31020 wxWindow *arg1 = (wxWindow *) 0 ;
31021 int arg2 ;
31022 void *argp1 = 0 ;
31023 int res1 = 0 ;
31024 int val2 ;
31025 int ecode2 = 0 ;
31026 PyObject * obj0 = 0 ;
31027 PyObject * obj1 = 0 ;
31028 char * kwnames[] = {
31029 (char *) "self",(char *) "winid", NULL
31030 };
31031
31032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31034 if (!SWIG_IsOK(res1)) {
31035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
31036 }
31037 arg1 = reinterpret_cast< wxWindow * >(argp1);
31038 ecode2 = SWIG_AsVal_int(obj1, &val2);
31039 if (!SWIG_IsOK(ecode2)) {
31040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
31041 }
31042 arg2 = static_cast< int >(val2);
31043 {
31044 PyThreadState* __tstate = wxPyBeginAllowThreads();
31045 (arg1)->SetId(arg2);
31046 wxPyEndAllowThreads(__tstate);
31047 if (PyErr_Occurred()) SWIG_fail;
31048 }
31049 resultobj = SWIG_Py_Void();
31050 return resultobj;
31051 fail:
31052 return NULL;
31053 }
31054
31055
31056 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31057 PyObject *resultobj = 0;
31058 wxWindow *arg1 = (wxWindow *) 0 ;
31059 int result;
31060 void *argp1 = 0 ;
31061 int res1 = 0 ;
31062 PyObject *swig_obj[1] ;
31063
31064 if (!args) SWIG_fail;
31065 swig_obj[0] = args;
31066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31067 if (!SWIG_IsOK(res1)) {
31068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
31069 }
31070 arg1 = reinterpret_cast< wxWindow * >(argp1);
31071 {
31072 PyThreadState* __tstate = wxPyBeginAllowThreads();
31073 result = (int)((wxWindow const *)arg1)->GetId();
31074 wxPyEndAllowThreads(__tstate);
31075 if (PyErr_Occurred()) SWIG_fail;
31076 }
31077 resultobj = SWIG_From_int(static_cast< int >(result));
31078 return resultobj;
31079 fail:
31080 return NULL;
31081 }
31082
31083
31084 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31085 PyObject *resultobj = 0;
31086 int result;
31087
31088 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
31089 {
31090 PyThreadState* __tstate = wxPyBeginAllowThreads();
31091 result = (int)wxWindow::NewControlId();
31092 wxPyEndAllowThreads(__tstate);
31093 if (PyErr_Occurred()) SWIG_fail;
31094 }
31095 resultobj = SWIG_From_int(static_cast< int >(result));
31096 return resultobj;
31097 fail:
31098 return NULL;
31099 }
31100
31101
31102 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31103 PyObject *resultobj = 0;
31104 int arg1 ;
31105 int result;
31106 int val1 ;
31107 int ecode1 = 0 ;
31108 PyObject * obj0 = 0 ;
31109 char * kwnames[] = {
31110 (char *) "winid", NULL
31111 };
31112
31113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
31114 ecode1 = SWIG_AsVal_int(obj0, &val1);
31115 if (!SWIG_IsOK(ecode1)) {
31116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
31117 }
31118 arg1 = static_cast< int >(val1);
31119 {
31120 PyThreadState* __tstate = wxPyBeginAllowThreads();
31121 result = (int)wxWindow::NextControlId(arg1);
31122 wxPyEndAllowThreads(__tstate);
31123 if (PyErr_Occurred()) SWIG_fail;
31124 }
31125 resultobj = SWIG_From_int(static_cast< int >(result));
31126 return resultobj;
31127 fail:
31128 return NULL;
31129 }
31130
31131
31132 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31133 PyObject *resultobj = 0;
31134 int arg1 ;
31135 int result;
31136 int val1 ;
31137 int ecode1 = 0 ;
31138 PyObject * obj0 = 0 ;
31139 char * kwnames[] = {
31140 (char *) "winid", NULL
31141 };
31142
31143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
31144 ecode1 = SWIG_AsVal_int(obj0, &val1);
31145 if (!SWIG_IsOK(ecode1)) {
31146 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
31147 }
31148 arg1 = static_cast< int >(val1);
31149 {
31150 PyThreadState* __tstate = wxPyBeginAllowThreads();
31151 result = (int)wxWindow::PrevControlId(arg1);
31152 wxPyEndAllowThreads(__tstate);
31153 if (PyErr_Occurred()) SWIG_fail;
31154 }
31155 resultobj = SWIG_From_int(static_cast< int >(result));
31156 return resultobj;
31157 fail:
31158 return NULL;
31159 }
31160
31161
31162 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31163 PyObject *resultobj = 0;
31164 wxWindow *arg1 = (wxWindow *) 0 ;
31165 wxLayoutDirection result;
31166 void *argp1 = 0 ;
31167 int res1 = 0 ;
31168 PyObject *swig_obj[1] ;
31169
31170 if (!args) SWIG_fail;
31171 swig_obj[0] = args;
31172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31173 if (!SWIG_IsOK(res1)) {
31174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31175 }
31176 arg1 = reinterpret_cast< wxWindow * >(argp1);
31177 {
31178 PyThreadState* __tstate = wxPyBeginAllowThreads();
31179 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
31180 wxPyEndAllowThreads(__tstate);
31181 if (PyErr_Occurred()) SWIG_fail;
31182 }
31183 resultobj = SWIG_From_int(static_cast< int >(result));
31184 return resultobj;
31185 fail:
31186 return NULL;
31187 }
31188
31189
31190 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31191 PyObject *resultobj = 0;
31192 wxWindow *arg1 = (wxWindow *) 0 ;
31193 wxLayoutDirection arg2 ;
31194 void *argp1 = 0 ;
31195 int res1 = 0 ;
31196 int val2 ;
31197 int ecode2 = 0 ;
31198 PyObject * obj0 = 0 ;
31199 PyObject * obj1 = 0 ;
31200 char * kwnames[] = {
31201 (char *) "self",(char *) "dir", NULL
31202 };
31203
31204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
31205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31206 if (!SWIG_IsOK(res1)) {
31207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
31208 }
31209 arg1 = reinterpret_cast< wxWindow * >(argp1);
31210 ecode2 = SWIG_AsVal_int(obj1, &val2);
31211 if (!SWIG_IsOK(ecode2)) {
31212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
31213 }
31214 arg2 = static_cast< wxLayoutDirection >(val2);
31215 {
31216 PyThreadState* __tstate = wxPyBeginAllowThreads();
31217 (arg1)->SetLayoutDirection(arg2);
31218 wxPyEndAllowThreads(__tstate);
31219 if (PyErr_Occurred()) SWIG_fail;
31220 }
31221 resultobj = SWIG_Py_Void();
31222 return resultobj;
31223 fail:
31224 return NULL;
31225 }
31226
31227
31228 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31229 PyObject *resultobj = 0;
31230 wxWindow *arg1 = (wxWindow *) 0 ;
31231 int arg2 ;
31232 int arg3 ;
31233 int arg4 ;
31234 int result;
31235 void *argp1 = 0 ;
31236 int res1 = 0 ;
31237 int val2 ;
31238 int ecode2 = 0 ;
31239 int val3 ;
31240 int ecode3 = 0 ;
31241 int val4 ;
31242 int ecode4 = 0 ;
31243 PyObject * obj0 = 0 ;
31244 PyObject * obj1 = 0 ;
31245 PyObject * obj2 = 0 ;
31246 PyObject * obj3 = 0 ;
31247 char * kwnames[] = {
31248 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
31249 };
31250
31251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31253 if (!SWIG_IsOK(res1)) {
31254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31255 }
31256 arg1 = reinterpret_cast< wxWindow * >(argp1);
31257 ecode2 = SWIG_AsVal_int(obj1, &val2);
31258 if (!SWIG_IsOK(ecode2)) {
31259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
31260 }
31261 arg2 = static_cast< int >(val2);
31262 ecode3 = SWIG_AsVal_int(obj2, &val3);
31263 if (!SWIG_IsOK(ecode3)) {
31264 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
31265 }
31266 arg3 = static_cast< int >(val3);
31267 ecode4 = SWIG_AsVal_int(obj3, &val4);
31268 if (!SWIG_IsOK(ecode4)) {
31269 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
31270 }
31271 arg4 = static_cast< int >(val4);
31272 {
31273 PyThreadState* __tstate = wxPyBeginAllowThreads();
31274 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
31275 wxPyEndAllowThreads(__tstate);
31276 if (PyErr_Occurred()) SWIG_fail;
31277 }
31278 resultobj = SWIG_From_int(static_cast< int >(result));
31279 return resultobj;
31280 fail:
31281 return NULL;
31282 }
31283
31284
31285 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31286 PyObject *resultobj = 0;
31287 wxWindow *arg1 = (wxWindow *) 0 ;
31288 wxSize *arg2 = 0 ;
31289 void *argp1 = 0 ;
31290 int res1 = 0 ;
31291 wxSize temp2 ;
31292 PyObject * obj0 = 0 ;
31293 PyObject * obj1 = 0 ;
31294 char * kwnames[] = {
31295 (char *) "self",(char *) "size", NULL
31296 };
31297
31298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
31299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31300 if (!SWIG_IsOK(res1)) {
31301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31302 }
31303 arg1 = reinterpret_cast< wxWindow * >(argp1);
31304 {
31305 arg2 = &temp2;
31306 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31307 }
31308 {
31309 PyThreadState* __tstate = wxPyBeginAllowThreads();
31310 (arg1)->SetSize((wxSize const &)*arg2);
31311 wxPyEndAllowThreads(__tstate);
31312 if (PyErr_Occurred()) SWIG_fail;
31313 }
31314 resultobj = SWIG_Py_Void();
31315 return resultobj;
31316 fail:
31317 return NULL;
31318 }
31319
31320
31321 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31322 PyObject *resultobj = 0;
31323 wxWindow *arg1 = (wxWindow *) 0 ;
31324 int arg2 ;
31325 int arg3 ;
31326 int arg4 ;
31327 int arg5 ;
31328 int arg6 = (int) wxSIZE_AUTO ;
31329 void *argp1 = 0 ;
31330 int res1 = 0 ;
31331 int val2 ;
31332 int ecode2 = 0 ;
31333 int val3 ;
31334 int ecode3 = 0 ;
31335 int val4 ;
31336 int ecode4 = 0 ;
31337 int val5 ;
31338 int ecode5 = 0 ;
31339 int val6 ;
31340 int ecode6 = 0 ;
31341 PyObject * obj0 = 0 ;
31342 PyObject * obj1 = 0 ;
31343 PyObject * obj2 = 0 ;
31344 PyObject * obj3 = 0 ;
31345 PyObject * obj4 = 0 ;
31346 PyObject * obj5 = 0 ;
31347 char * kwnames[] = {
31348 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
31349 };
31350
31351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31353 if (!SWIG_IsOK(res1)) {
31354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
31355 }
31356 arg1 = reinterpret_cast< wxWindow * >(argp1);
31357 ecode2 = SWIG_AsVal_int(obj1, &val2);
31358 if (!SWIG_IsOK(ecode2)) {
31359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
31360 }
31361 arg2 = static_cast< int >(val2);
31362 ecode3 = SWIG_AsVal_int(obj2, &val3);
31363 if (!SWIG_IsOK(ecode3)) {
31364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
31365 }
31366 arg3 = static_cast< int >(val3);
31367 ecode4 = SWIG_AsVal_int(obj3, &val4);
31368 if (!SWIG_IsOK(ecode4)) {
31369 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
31370 }
31371 arg4 = static_cast< int >(val4);
31372 ecode5 = SWIG_AsVal_int(obj4, &val5);
31373 if (!SWIG_IsOK(ecode5)) {
31374 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
31375 }
31376 arg5 = static_cast< int >(val5);
31377 if (obj5) {
31378 ecode6 = SWIG_AsVal_int(obj5, &val6);
31379 if (!SWIG_IsOK(ecode6)) {
31380 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
31381 }
31382 arg6 = static_cast< int >(val6);
31383 }
31384 {
31385 PyThreadState* __tstate = wxPyBeginAllowThreads();
31386 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
31387 wxPyEndAllowThreads(__tstate);
31388 if (PyErr_Occurred()) SWIG_fail;
31389 }
31390 resultobj = SWIG_Py_Void();
31391 return resultobj;
31392 fail:
31393 return NULL;
31394 }
31395
31396
31397 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31398 PyObject *resultobj = 0;
31399 wxWindow *arg1 = (wxWindow *) 0 ;
31400 wxRect *arg2 = 0 ;
31401 int arg3 = (int) wxSIZE_AUTO ;
31402 void *argp1 = 0 ;
31403 int res1 = 0 ;
31404 wxRect temp2 ;
31405 int val3 ;
31406 int ecode3 = 0 ;
31407 PyObject * obj0 = 0 ;
31408 PyObject * obj1 = 0 ;
31409 PyObject * obj2 = 0 ;
31410 char * kwnames[] = {
31411 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
31412 };
31413
31414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31416 if (!SWIG_IsOK(res1)) {
31417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31418 }
31419 arg1 = reinterpret_cast< wxWindow * >(argp1);
31420 {
31421 arg2 = &temp2;
31422 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31423 }
31424 if (obj2) {
31425 ecode3 = SWIG_AsVal_int(obj2, &val3);
31426 if (!SWIG_IsOK(ecode3)) {
31427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
31428 }
31429 arg3 = static_cast< int >(val3);
31430 }
31431 {
31432 PyThreadState* __tstate = wxPyBeginAllowThreads();
31433 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31434 wxPyEndAllowThreads(__tstate);
31435 if (PyErr_Occurred()) SWIG_fail;
31436 }
31437 resultobj = SWIG_Py_Void();
31438 return resultobj;
31439 fail:
31440 return NULL;
31441 }
31442
31443
31444 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31445 PyObject *resultobj = 0;
31446 wxWindow *arg1 = (wxWindow *) 0 ;
31447 int arg2 ;
31448 int arg3 ;
31449 void *argp1 = 0 ;
31450 int res1 = 0 ;
31451 int val2 ;
31452 int ecode2 = 0 ;
31453 int val3 ;
31454 int ecode3 = 0 ;
31455 PyObject * obj0 = 0 ;
31456 PyObject * obj1 = 0 ;
31457 PyObject * obj2 = 0 ;
31458 char * kwnames[] = {
31459 (char *) "self",(char *) "width",(char *) "height", NULL
31460 };
31461
31462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31464 if (!SWIG_IsOK(res1)) {
31465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31466 }
31467 arg1 = reinterpret_cast< wxWindow * >(argp1);
31468 ecode2 = SWIG_AsVal_int(obj1, &val2);
31469 if (!SWIG_IsOK(ecode2)) {
31470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31471 }
31472 arg2 = static_cast< int >(val2);
31473 ecode3 = SWIG_AsVal_int(obj2, &val3);
31474 if (!SWIG_IsOK(ecode3)) {
31475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31476 }
31477 arg3 = static_cast< int >(val3);
31478 {
31479 PyThreadState* __tstate = wxPyBeginAllowThreads();
31480 (arg1)->SetSize(arg2,arg3);
31481 wxPyEndAllowThreads(__tstate);
31482 if (PyErr_Occurred()) SWIG_fail;
31483 }
31484 resultobj = SWIG_Py_Void();
31485 return resultobj;
31486 fail:
31487 return NULL;
31488 }
31489
31490
31491 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31492 PyObject *resultobj = 0;
31493 wxWindow *arg1 = (wxWindow *) 0 ;
31494 wxPoint *arg2 = 0 ;
31495 int arg3 = (int) wxSIZE_USE_EXISTING ;
31496 void *argp1 = 0 ;
31497 int res1 = 0 ;
31498 wxPoint temp2 ;
31499 int val3 ;
31500 int ecode3 = 0 ;
31501 PyObject * obj0 = 0 ;
31502 PyObject * obj1 = 0 ;
31503 PyObject * obj2 = 0 ;
31504 char * kwnames[] = {
31505 (char *) "self",(char *) "pt",(char *) "flags", NULL
31506 };
31507
31508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31510 if (!SWIG_IsOK(res1)) {
31511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31512 }
31513 arg1 = reinterpret_cast< wxWindow * >(argp1);
31514 {
31515 arg2 = &temp2;
31516 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31517 }
31518 if (obj2) {
31519 ecode3 = SWIG_AsVal_int(obj2, &val3);
31520 if (!SWIG_IsOK(ecode3)) {
31521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31522 }
31523 arg3 = static_cast< int >(val3);
31524 }
31525 {
31526 PyThreadState* __tstate = wxPyBeginAllowThreads();
31527 (arg1)->Move((wxPoint const &)*arg2,arg3);
31528 wxPyEndAllowThreads(__tstate);
31529 if (PyErr_Occurred()) SWIG_fail;
31530 }
31531 resultobj = SWIG_Py_Void();
31532 return resultobj;
31533 fail:
31534 return NULL;
31535 }
31536
31537
31538 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31539 PyObject *resultobj = 0;
31540 wxWindow *arg1 = (wxWindow *) 0 ;
31541 int arg2 ;
31542 int arg3 ;
31543 int arg4 = (int) wxSIZE_USE_EXISTING ;
31544 void *argp1 = 0 ;
31545 int res1 = 0 ;
31546 int val2 ;
31547 int ecode2 = 0 ;
31548 int val3 ;
31549 int ecode3 = 0 ;
31550 int val4 ;
31551 int ecode4 = 0 ;
31552 PyObject * obj0 = 0 ;
31553 PyObject * obj1 = 0 ;
31554 PyObject * obj2 = 0 ;
31555 PyObject * obj3 = 0 ;
31556 char * kwnames[] = {
31557 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31558 };
31559
31560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31562 if (!SWIG_IsOK(res1)) {
31563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31564 }
31565 arg1 = reinterpret_cast< wxWindow * >(argp1);
31566 ecode2 = SWIG_AsVal_int(obj1, &val2);
31567 if (!SWIG_IsOK(ecode2)) {
31568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31569 }
31570 arg2 = static_cast< int >(val2);
31571 ecode3 = SWIG_AsVal_int(obj2, &val3);
31572 if (!SWIG_IsOK(ecode3)) {
31573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31574 }
31575 arg3 = static_cast< int >(val3);
31576 if (obj3) {
31577 ecode4 = SWIG_AsVal_int(obj3, &val4);
31578 if (!SWIG_IsOK(ecode4)) {
31579 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31580 }
31581 arg4 = static_cast< int >(val4);
31582 }
31583 {
31584 PyThreadState* __tstate = wxPyBeginAllowThreads();
31585 (arg1)->Move(arg2,arg3,arg4);
31586 wxPyEndAllowThreads(__tstate);
31587 if (PyErr_Occurred()) SWIG_fail;
31588 }
31589 resultobj = SWIG_Py_Void();
31590 return resultobj;
31591 fail:
31592 return NULL;
31593 }
31594
31595
31596 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31597 PyObject *resultobj = 0;
31598 wxWindow *arg1 = (wxWindow *) 0 ;
31599 wxSize const &arg2_defvalue = wxDefaultSize ;
31600 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31601 void *argp1 = 0 ;
31602 int res1 = 0 ;
31603 wxSize temp2 ;
31604 PyObject * obj0 = 0 ;
31605 PyObject * obj1 = 0 ;
31606 char * kwnames[] = {
31607 (char *) "self",(char *) "size", NULL
31608 };
31609
31610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31612 if (!SWIG_IsOK(res1)) {
31613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31614 }
31615 arg1 = reinterpret_cast< wxWindow * >(argp1);
31616 if (obj1) {
31617 {
31618 arg2 = &temp2;
31619 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31620 }
31621 }
31622 {
31623 PyThreadState* __tstate = wxPyBeginAllowThreads();
31624 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31625 wxPyEndAllowThreads(__tstate);
31626 if (PyErr_Occurred()) SWIG_fail;
31627 }
31628 resultobj = SWIG_Py_Void();
31629 return resultobj;
31630 fail:
31631 return NULL;
31632 }
31633
31634
31635 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31636 PyObject *resultobj = 0;
31637 wxWindow *arg1 = (wxWindow *) 0 ;
31638 void *argp1 = 0 ;
31639 int res1 = 0 ;
31640 PyObject *swig_obj[1] ;
31641
31642 if (!args) SWIG_fail;
31643 swig_obj[0] = args;
31644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31645 if (!SWIG_IsOK(res1)) {
31646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31647 }
31648 arg1 = reinterpret_cast< wxWindow * >(argp1);
31649 {
31650 PyThreadState* __tstate = wxPyBeginAllowThreads();
31651 (arg1)->Raise();
31652 wxPyEndAllowThreads(__tstate);
31653 if (PyErr_Occurred()) SWIG_fail;
31654 }
31655 resultobj = SWIG_Py_Void();
31656 return resultobj;
31657 fail:
31658 return NULL;
31659 }
31660
31661
31662 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31663 PyObject *resultobj = 0;
31664 wxWindow *arg1 = (wxWindow *) 0 ;
31665 void *argp1 = 0 ;
31666 int res1 = 0 ;
31667 PyObject *swig_obj[1] ;
31668
31669 if (!args) SWIG_fail;
31670 swig_obj[0] = args;
31671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31672 if (!SWIG_IsOK(res1)) {
31673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31674 }
31675 arg1 = reinterpret_cast< wxWindow * >(argp1);
31676 {
31677 PyThreadState* __tstate = wxPyBeginAllowThreads();
31678 (arg1)->Lower();
31679 wxPyEndAllowThreads(__tstate);
31680 if (PyErr_Occurred()) SWIG_fail;
31681 }
31682 resultobj = SWIG_Py_Void();
31683 return resultobj;
31684 fail:
31685 return NULL;
31686 }
31687
31688
31689 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31690 PyObject *resultobj = 0;
31691 wxWindow *arg1 = (wxWindow *) 0 ;
31692 wxSize *arg2 = 0 ;
31693 void *argp1 = 0 ;
31694 int res1 = 0 ;
31695 wxSize temp2 ;
31696 PyObject * obj0 = 0 ;
31697 PyObject * obj1 = 0 ;
31698 char * kwnames[] = {
31699 (char *) "self",(char *) "size", NULL
31700 };
31701
31702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31704 if (!SWIG_IsOK(res1)) {
31705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31706 }
31707 arg1 = reinterpret_cast< wxWindow * >(argp1);
31708 {
31709 arg2 = &temp2;
31710 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31711 }
31712 {
31713 PyThreadState* __tstate = wxPyBeginAllowThreads();
31714 (arg1)->SetClientSize((wxSize const &)*arg2);
31715 wxPyEndAllowThreads(__tstate);
31716 if (PyErr_Occurred()) SWIG_fail;
31717 }
31718 resultobj = SWIG_Py_Void();
31719 return resultobj;
31720 fail:
31721 return NULL;
31722 }
31723
31724
31725 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31726 PyObject *resultobj = 0;
31727 wxWindow *arg1 = (wxWindow *) 0 ;
31728 int arg2 ;
31729 int arg3 ;
31730 void *argp1 = 0 ;
31731 int res1 = 0 ;
31732 int val2 ;
31733 int ecode2 = 0 ;
31734 int val3 ;
31735 int ecode3 = 0 ;
31736 PyObject * obj0 = 0 ;
31737 PyObject * obj1 = 0 ;
31738 PyObject * obj2 = 0 ;
31739 char * kwnames[] = {
31740 (char *) "self",(char *) "width",(char *) "height", NULL
31741 };
31742
31743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31745 if (!SWIG_IsOK(res1)) {
31746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31747 }
31748 arg1 = reinterpret_cast< wxWindow * >(argp1);
31749 ecode2 = SWIG_AsVal_int(obj1, &val2);
31750 if (!SWIG_IsOK(ecode2)) {
31751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31752 }
31753 arg2 = static_cast< int >(val2);
31754 ecode3 = SWIG_AsVal_int(obj2, &val3);
31755 if (!SWIG_IsOK(ecode3)) {
31756 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31757 }
31758 arg3 = static_cast< int >(val3);
31759 {
31760 PyThreadState* __tstate = wxPyBeginAllowThreads();
31761 (arg1)->SetClientSize(arg2,arg3);
31762 wxPyEndAllowThreads(__tstate);
31763 if (PyErr_Occurred()) SWIG_fail;
31764 }
31765 resultobj = SWIG_Py_Void();
31766 return resultobj;
31767 fail:
31768 return NULL;
31769 }
31770
31771
31772 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31773 PyObject *resultobj = 0;
31774 wxWindow *arg1 = (wxWindow *) 0 ;
31775 wxRect *arg2 = 0 ;
31776 void *argp1 = 0 ;
31777 int res1 = 0 ;
31778 wxRect temp2 ;
31779 PyObject * obj0 = 0 ;
31780 PyObject * obj1 = 0 ;
31781 char * kwnames[] = {
31782 (char *) "self",(char *) "rect", NULL
31783 };
31784
31785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31787 if (!SWIG_IsOK(res1)) {
31788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31789 }
31790 arg1 = reinterpret_cast< wxWindow * >(argp1);
31791 {
31792 arg2 = &temp2;
31793 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31794 }
31795 {
31796 PyThreadState* __tstate = wxPyBeginAllowThreads();
31797 (arg1)->SetClientSize((wxRect const &)*arg2);
31798 wxPyEndAllowThreads(__tstate);
31799 if (PyErr_Occurred()) SWIG_fail;
31800 }
31801 resultobj = SWIG_Py_Void();
31802 return resultobj;
31803 fail:
31804 return NULL;
31805 }
31806
31807
31808 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31809 PyObject *resultobj = 0;
31810 wxWindow *arg1 = (wxWindow *) 0 ;
31811 wxPoint result;
31812 void *argp1 = 0 ;
31813 int res1 = 0 ;
31814 PyObject *swig_obj[1] ;
31815
31816 if (!args) SWIG_fail;
31817 swig_obj[0] = args;
31818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31819 if (!SWIG_IsOK(res1)) {
31820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31821 }
31822 arg1 = reinterpret_cast< wxWindow * >(argp1);
31823 {
31824 PyThreadState* __tstate = wxPyBeginAllowThreads();
31825 result = ((wxWindow const *)arg1)->GetPosition();
31826 wxPyEndAllowThreads(__tstate);
31827 if (PyErr_Occurred()) SWIG_fail;
31828 }
31829 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31830 return resultobj;
31831 fail:
31832 return NULL;
31833 }
31834
31835
31836 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31837 PyObject *resultobj = 0;
31838 wxWindow *arg1 = (wxWindow *) 0 ;
31839 int *arg2 = (int *) 0 ;
31840 int *arg3 = (int *) 0 ;
31841 void *argp1 = 0 ;
31842 int res1 = 0 ;
31843 int temp2 ;
31844 int res2 = SWIG_TMPOBJ ;
31845 int temp3 ;
31846 int res3 = SWIG_TMPOBJ ;
31847 PyObject *swig_obj[1] ;
31848
31849 arg2 = &temp2;
31850 arg3 = &temp3;
31851 if (!args) SWIG_fail;
31852 swig_obj[0] = args;
31853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31854 if (!SWIG_IsOK(res1)) {
31855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31856 }
31857 arg1 = reinterpret_cast< wxWindow * >(argp1);
31858 {
31859 PyThreadState* __tstate = wxPyBeginAllowThreads();
31860 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31861 wxPyEndAllowThreads(__tstate);
31862 if (PyErr_Occurred()) SWIG_fail;
31863 }
31864 resultobj = SWIG_Py_Void();
31865 if (SWIG_IsTmpObj(res2)) {
31866 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31867 } else {
31868 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31869 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31870 }
31871 if (SWIG_IsTmpObj(res3)) {
31872 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31873 } else {
31874 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31875 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31876 }
31877 return resultobj;
31878 fail:
31879 return NULL;
31880 }
31881
31882
31883 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31884 PyObject *resultobj = 0;
31885 wxWindow *arg1 = (wxWindow *) 0 ;
31886 wxPoint result;
31887 void *argp1 = 0 ;
31888 int res1 = 0 ;
31889 PyObject *swig_obj[1] ;
31890
31891 if (!args) SWIG_fail;
31892 swig_obj[0] = args;
31893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31894 if (!SWIG_IsOK(res1)) {
31895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31896 }
31897 arg1 = reinterpret_cast< wxWindow * >(argp1);
31898 {
31899 PyThreadState* __tstate = wxPyBeginAllowThreads();
31900 result = ((wxWindow const *)arg1)->GetScreenPosition();
31901 wxPyEndAllowThreads(__tstate);
31902 if (PyErr_Occurred()) SWIG_fail;
31903 }
31904 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31905 return resultobj;
31906 fail:
31907 return NULL;
31908 }
31909
31910
31911 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31912 PyObject *resultobj = 0;
31913 wxWindow *arg1 = (wxWindow *) 0 ;
31914 int *arg2 = (int *) 0 ;
31915 int *arg3 = (int *) 0 ;
31916 void *argp1 = 0 ;
31917 int res1 = 0 ;
31918 int temp2 ;
31919 int res2 = SWIG_TMPOBJ ;
31920 int temp3 ;
31921 int res3 = SWIG_TMPOBJ ;
31922 PyObject *swig_obj[1] ;
31923
31924 arg2 = &temp2;
31925 arg3 = &temp3;
31926 if (!args) SWIG_fail;
31927 swig_obj[0] = args;
31928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31929 if (!SWIG_IsOK(res1)) {
31930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31931 }
31932 arg1 = reinterpret_cast< wxWindow * >(argp1);
31933 {
31934 PyThreadState* __tstate = wxPyBeginAllowThreads();
31935 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31936 wxPyEndAllowThreads(__tstate);
31937 if (PyErr_Occurred()) SWIG_fail;
31938 }
31939 resultobj = SWIG_Py_Void();
31940 if (SWIG_IsTmpObj(res2)) {
31941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31942 } else {
31943 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31944 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31945 }
31946 if (SWIG_IsTmpObj(res3)) {
31947 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31948 } else {
31949 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31950 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31951 }
31952 return resultobj;
31953 fail:
31954 return NULL;
31955 }
31956
31957
31958 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31959 PyObject *resultobj = 0;
31960 wxWindow *arg1 = (wxWindow *) 0 ;
31961 wxRect result;
31962 void *argp1 = 0 ;
31963 int res1 = 0 ;
31964 PyObject *swig_obj[1] ;
31965
31966 if (!args) SWIG_fail;
31967 swig_obj[0] = args;
31968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31969 if (!SWIG_IsOK(res1)) {
31970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31971 }
31972 arg1 = reinterpret_cast< wxWindow * >(argp1);
31973 {
31974 PyThreadState* __tstate = wxPyBeginAllowThreads();
31975 result = ((wxWindow const *)arg1)->GetScreenRect();
31976 wxPyEndAllowThreads(__tstate);
31977 if (PyErr_Occurred()) SWIG_fail;
31978 }
31979 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31980 return resultobj;
31981 fail:
31982 return NULL;
31983 }
31984
31985
31986 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31987 PyObject *resultobj = 0;
31988 wxWindow *arg1 = (wxWindow *) 0 ;
31989 wxSize result;
31990 void *argp1 = 0 ;
31991 int res1 = 0 ;
31992 PyObject *swig_obj[1] ;
31993
31994 if (!args) SWIG_fail;
31995 swig_obj[0] = args;
31996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31997 if (!SWIG_IsOK(res1)) {
31998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31999 }
32000 arg1 = reinterpret_cast< wxWindow * >(argp1);
32001 {
32002 PyThreadState* __tstate = wxPyBeginAllowThreads();
32003 result = ((wxWindow const *)arg1)->GetSize();
32004 wxPyEndAllowThreads(__tstate);
32005 if (PyErr_Occurred()) SWIG_fail;
32006 }
32007 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32008 return resultobj;
32009 fail:
32010 return NULL;
32011 }
32012
32013
32014 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32015 PyObject *resultobj = 0;
32016 wxWindow *arg1 = (wxWindow *) 0 ;
32017 int *arg2 = (int *) 0 ;
32018 int *arg3 = (int *) 0 ;
32019 void *argp1 = 0 ;
32020 int res1 = 0 ;
32021 int temp2 ;
32022 int res2 = SWIG_TMPOBJ ;
32023 int temp3 ;
32024 int res3 = SWIG_TMPOBJ ;
32025 PyObject *swig_obj[1] ;
32026
32027 arg2 = &temp2;
32028 arg3 = &temp3;
32029 if (!args) SWIG_fail;
32030 swig_obj[0] = args;
32031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32032 if (!SWIG_IsOK(res1)) {
32033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32034 }
32035 arg1 = reinterpret_cast< wxWindow * >(argp1);
32036 {
32037 PyThreadState* __tstate = wxPyBeginAllowThreads();
32038 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
32039 wxPyEndAllowThreads(__tstate);
32040 if (PyErr_Occurred()) SWIG_fail;
32041 }
32042 resultobj = SWIG_Py_Void();
32043 if (SWIG_IsTmpObj(res2)) {
32044 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32045 } else {
32046 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32047 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32048 }
32049 if (SWIG_IsTmpObj(res3)) {
32050 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32051 } else {
32052 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32053 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32054 }
32055 return resultobj;
32056 fail:
32057 return NULL;
32058 }
32059
32060
32061 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32062 PyObject *resultobj = 0;
32063 wxWindow *arg1 = (wxWindow *) 0 ;
32064 wxRect result;
32065 void *argp1 = 0 ;
32066 int res1 = 0 ;
32067 PyObject *swig_obj[1] ;
32068
32069 if (!args) SWIG_fail;
32070 swig_obj[0] = args;
32071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32072 if (!SWIG_IsOK(res1)) {
32073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32074 }
32075 arg1 = reinterpret_cast< wxWindow * >(argp1);
32076 {
32077 PyThreadState* __tstate = wxPyBeginAllowThreads();
32078 result = ((wxWindow const *)arg1)->GetRect();
32079 wxPyEndAllowThreads(__tstate);
32080 if (PyErr_Occurred()) SWIG_fail;
32081 }
32082 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32083 return resultobj;
32084 fail:
32085 return NULL;
32086 }
32087
32088
32089 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32090 PyObject *resultobj = 0;
32091 wxWindow *arg1 = (wxWindow *) 0 ;
32092 wxSize result;
32093 void *argp1 = 0 ;
32094 int res1 = 0 ;
32095 PyObject *swig_obj[1] ;
32096
32097 if (!args) SWIG_fail;
32098 swig_obj[0] = args;
32099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32100 if (!SWIG_IsOK(res1)) {
32101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32102 }
32103 arg1 = reinterpret_cast< wxWindow * >(argp1);
32104 {
32105 PyThreadState* __tstate = wxPyBeginAllowThreads();
32106 result = ((wxWindow const *)arg1)->GetClientSize();
32107 wxPyEndAllowThreads(__tstate);
32108 if (PyErr_Occurred()) SWIG_fail;
32109 }
32110 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32111 return resultobj;
32112 fail:
32113 return NULL;
32114 }
32115
32116
32117 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32118 PyObject *resultobj = 0;
32119 wxWindow *arg1 = (wxWindow *) 0 ;
32120 int *arg2 = (int *) 0 ;
32121 int *arg3 = (int *) 0 ;
32122 void *argp1 = 0 ;
32123 int res1 = 0 ;
32124 int temp2 ;
32125 int res2 = SWIG_TMPOBJ ;
32126 int temp3 ;
32127 int res3 = SWIG_TMPOBJ ;
32128 PyObject *swig_obj[1] ;
32129
32130 arg2 = &temp2;
32131 arg3 = &temp3;
32132 if (!args) SWIG_fail;
32133 swig_obj[0] = args;
32134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32135 if (!SWIG_IsOK(res1)) {
32136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32137 }
32138 arg1 = reinterpret_cast< wxWindow * >(argp1);
32139 {
32140 PyThreadState* __tstate = wxPyBeginAllowThreads();
32141 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
32142 wxPyEndAllowThreads(__tstate);
32143 if (PyErr_Occurred()) SWIG_fail;
32144 }
32145 resultobj = SWIG_Py_Void();
32146 if (SWIG_IsTmpObj(res2)) {
32147 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32148 } else {
32149 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32150 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32151 }
32152 if (SWIG_IsTmpObj(res3)) {
32153 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32154 } else {
32155 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32156 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32157 }
32158 return resultobj;
32159 fail:
32160 return NULL;
32161 }
32162
32163
32164 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32165 PyObject *resultobj = 0;
32166 wxWindow *arg1 = (wxWindow *) 0 ;
32167 wxPoint result;
32168 void *argp1 = 0 ;
32169 int res1 = 0 ;
32170 PyObject *swig_obj[1] ;
32171
32172 if (!args) SWIG_fail;
32173 swig_obj[0] = args;
32174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32175 if (!SWIG_IsOK(res1)) {
32176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
32177 }
32178 arg1 = reinterpret_cast< wxWindow * >(argp1);
32179 {
32180 PyThreadState* __tstate = wxPyBeginAllowThreads();
32181 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
32182 wxPyEndAllowThreads(__tstate);
32183 if (PyErr_Occurred()) SWIG_fail;
32184 }
32185 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32186 return resultobj;
32187 fail:
32188 return NULL;
32189 }
32190
32191
32192 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32193 PyObject *resultobj = 0;
32194 wxWindow *arg1 = (wxWindow *) 0 ;
32195 wxRect result;
32196 void *argp1 = 0 ;
32197 int res1 = 0 ;
32198 PyObject *swig_obj[1] ;
32199
32200 if (!args) SWIG_fail;
32201 swig_obj[0] = args;
32202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32203 if (!SWIG_IsOK(res1)) {
32204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32205 }
32206 arg1 = reinterpret_cast< wxWindow * >(argp1);
32207 {
32208 PyThreadState* __tstate = wxPyBeginAllowThreads();
32209 result = ((wxWindow const *)arg1)->GetClientRect();
32210 wxPyEndAllowThreads(__tstate);
32211 if (PyErr_Occurred()) SWIG_fail;
32212 }
32213 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32214 return resultobj;
32215 fail:
32216 return NULL;
32217 }
32218
32219
32220 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32221 PyObject *resultobj = 0;
32222 wxWindow *arg1 = (wxWindow *) 0 ;
32223 wxSize result;
32224 void *argp1 = 0 ;
32225 int res1 = 0 ;
32226 PyObject *swig_obj[1] ;
32227
32228 if (!args) SWIG_fail;
32229 swig_obj[0] = args;
32230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32231 if (!SWIG_IsOK(res1)) {
32232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32233 }
32234 arg1 = reinterpret_cast< wxWindow * >(argp1);
32235 {
32236 PyThreadState* __tstate = wxPyBeginAllowThreads();
32237 result = ((wxWindow const *)arg1)->GetBestSize();
32238 wxPyEndAllowThreads(__tstate);
32239 if (PyErr_Occurred()) SWIG_fail;
32240 }
32241 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32242 return resultobj;
32243 fail:
32244 return NULL;
32245 }
32246
32247
32248 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32249 PyObject *resultobj = 0;
32250 wxWindow *arg1 = (wxWindow *) 0 ;
32251 int *arg2 = (int *) 0 ;
32252 int *arg3 = (int *) 0 ;
32253 void *argp1 = 0 ;
32254 int res1 = 0 ;
32255 int temp2 ;
32256 int res2 = SWIG_TMPOBJ ;
32257 int temp3 ;
32258 int res3 = SWIG_TMPOBJ ;
32259 PyObject *swig_obj[1] ;
32260
32261 arg2 = &temp2;
32262 arg3 = &temp3;
32263 if (!args) SWIG_fail;
32264 swig_obj[0] = args;
32265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32266 if (!SWIG_IsOK(res1)) {
32267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32268 }
32269 arg1 = reinterpret_cast< wxWindow * >(argp1);
32270 {
32271 PyThreadState* __tstate = wxPyBeginAllowThreads();
32272 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
32273 wxPyEndAllowThreads(__tstate);
32274 if (PyErr_Occurred()) SWIG_fail;
32275 }
32276 resultobj = SWIG_Py_Void();
32277 if (SWIG_IsTmpObj(res2)) {
32278 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32279 } else {
32280 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32281 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32282 }
32283 if (SWIG_IsTmpObj(res3)) {
32284 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32285 } else {
32286 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32287 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32288 }
32289 return resultobj;
32290 fail:
32291 return NULL;
32292 }
32293
32294
32295 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32296 PyObject *resultobj = 0;
32297 wxWindow *arg1 = (wxWindow *) 0 ;
32298 void *argp1 = 0 ;
32299 int res1 = 0 ;
32300 PyObject *swig_obj[1] ;
32301
32302 if (!args) SWIG_fail;
32303 swig_obj[0] = args;
32304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32305 if (!SWIG_IsOK(res1)) {
32306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32307 }
32308 arg1 = reinterpret_cast< wxWindow * >(argp1);
32309 {
32310 PyThreadState* __tstate = wxPyBeginAllowThreads();
32311 (arg1)->InvalidateBestSize();
32312 wxPyEndAllowThreads(__tstate);
32313 if (PyErr_Occurred()) SWIG_fail;
32314 }
32315 resultobj = SWIG_Py_Void();
32316 return resultobj;
32317 fail:
32318 return NULL;
32319 }
32320
32321
32322 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32323 PyObject *resultobj = 0;
32324 wxWindow *arg1 = (wxWindow *) 0 ;
32325 wxSize *arg2 = 0 ;
32326 void *argp1 = 0 ;
32327 int res1 = 0 ;
32328 wxSize temp2 ;
32329 PyObject * obj0 = 0 ;
32330 PyObject * obj1 = 0 ;
32331 char * kwnames[] = {
32332 (char *) "self",(char *) "size", NULL
32333 };
32334
32335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
32336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32337 if (!SWIG_IsOK(res1)) {
32338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32339 }
32340 arg1 = reinterpret_cast< wxWindow * >(argp1);
32341 {
32342 arg2 = &temp2;
32343 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32344 }
32345 {
32346 PyThreadState* __tstate = wxPyBeginAllowThreads();
32347 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
32348 wxPyEndAllowThreads(__tstate);
32349 if (PyErr_Occurred()) SWIG_fail;
32350 }
32351 resultobj = SWIG_Py_Void();
32352 return resultobj;
32353 fail:
32354 return NULL;
32355 }
32356
32357
32358 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32359 PyObject *resultobj = 0;
32360 wxWindow *arg1 = (wxWindow *) 0 ;
32361 wxSize result;
32362 void *argp1 = 0 ;
32363 int res1 = 0 ;
32364 PyObject *swig_obj[1] ;
32365
32366 if (!args) SWIG_fail;
32367 swig_obj[0] = args;
32368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32369 if (!SWIG_IsOK(res1)) {
32370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32371 }
32372 arg1 = reinterpret_cast< wxWindow * >(argp1);
32373 {
32374 PyThreadState* __tstate = wxPyBeginAllowThreads();
32375 result = ((wxWindow const *)arg1)->GetBestFittingSize();
32376 wxPyEndAllowThreads(__tstate);
32377 if (PyErr_Occurred()) SWIG_fail;
32378 }
32379 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32380 return resultobj;
32381 fail:
32382 return NULL;
32383 }
32384
32385
32386 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32387 PyObject *resultobj = 0;
32388 wxWindow *arg1 = (wxWindow *) 0 ;
32389 wxSize result;
32390 void *argp1 = 0 ;
32391 int res1 = 0 ;
32392 PyObject *swig_obj[1] ;
32393
32394 if (!args) SWIG_fail;
32395 swig_obj[0] = args;
32396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32397 if (!SWIG_IsOK(res1)) {
32398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32399 }
32400 arg1 = reinterpret_cast< wxWindow * >(argp1);
32401 {
32402 PyThreadState* __tstate = wxPyBeginAllowThreads();
32403 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
32404 wxPyEndAllowThreads(__tstate);
32405 if (PyErr_Occurred()) SWIG_fail;
32406 }
32407 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32408 return resultobj;
32409 fail:
32410 return NULL;
32411 }
32412
32413
32414 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32415 PyObject *resultobj = 0;
32416 wxWindow *arg1 = (wxWindow *) 0 ;
32417 int arg2 = (int) wxBOTH ;
32418 void *argp1 = 0 ;
32419 int res1 = 0 ;
32420 int val2 ;
32421 int ecode2 = 0 ;
32422 PyObject * obj0 = 0 ;
32423 PyObject * obj1 = 0 ;
32424 char * kwnames[] = {
32425 (char *) "self",(char *) "direction", NULL
32426 };
32427
32428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
32429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32430 if (!SWIG_IsOK(res1)) {
32431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
32432 }
32433 arg1 = reinterpret_cast< wxWindow * >(argp1);
32434 if (obj1) {
32435 ecode2 = SWIG_AsVal_int(obj1, &val2);
32436 if (!SWIG_IsOK(ecode2)) {
32437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32438 }
32439 arg2 = static_cast< int >(val2);
32440 }
32441 {
32442 PyThreadState* __tstate = wxPyBeginAllowThreads();
32443 (arg1)->Center(arg2);
32444 wxPyEndAllowThreads(__tstate);
32445 if (PyErr_Occurred()) SWIG_fail;
32446 }
32447 resultobj = SWIG_Py_Void();
32448 return resultobj;
32449 fail:
32450 return NULL;
32451 }
32452
32453
32454 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32455 PyObject *resultobj = 0;
32456 wxWindow *arg1 = (wxWindow *) 0 ;
32457 int arg2 = (int) wxBOTH ;
32458 void *argp1 = 0 ;
32459 int res1 = 0 ;
32460 int val2 ;
32461 int ecode2 = 0 ;
32462 PyObject * obj0 = 0 ;
32463 PyObject * obj1 = 0 ;
32464 char * kwnames[] = {
32465 (char *) "self",(char *) "dir", NULL
32466 };
32467
32468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32470 if (!SWIG_IsOK(res1)) {
32471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32472 }
32473 arg1 = reinterpret_cast< wxWindow * >(argp1);
32474 if (obj1) {
32475 ecode2 = SWIG_AsVal_int(obj1, &val2);
32476 if (!SWIG_IsOK(ecode2)) {
32477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32478 }
32479 arg2 = static_cast< int >(val2);
32480 }
32481 {
32482 PyThreadState* __tstate = wxPyBeginAllowThreads();
32483 (arg1)->CenterOnParent(arg2);
32484 wxPyEndAllowThreads(__tstate);
32485 if (PyErr_Occurred()) SWIG_fail;
32486 }
32487 resultobj = SWIG_Py_Void();
32488 return resultobj;
32489 fail:
32490 return NULL;
32491 }
32492
32493
32494 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32495 PyObject *resultobj = 0;
32496 wxWindow *arg1 = (wxWindow *) 0 ;
32497 void *argp1 = 0 ;
32498 int res1 = 0 ;
32499 PyObject *swig_obj[1] ;
32500
32501 if (!args) SWIG_fail;
32502 swig_obj[0] = args;
32503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32504 if (!SWIG_IsOK(res1)) {
32505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32506 }
32507 arg1 = reinterpret_cast< wxWindow * >(argp1);
32508 {
32509 PyThreadState* __tstate = wxPyBeginAllowThreads();
32510 (arg1)->Fit();
32511 wxPyEndAllowThreads(__tstate);
32512 if (PyErr_Occurred()) SWIG_fail;
32513 }
32514 resultobj = SWIG_Py_Void();
32515 return resultobj;
32516 fail:
32517 return NULL;
32518 }
32519
32520
32521 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32522 PyObject *resultobj = 0;
32523 wxWindow *arg1 = (wxWindow *) 0 ;
32524 void *argp1 = 0 ;
32525 int res1 = 0 ;
32526 PyObject *swig_obj[1] ;
32527
32528 if (!args) SWIG_fail;
32529 swig_obj[0] = args;
32530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32531 if (!SWIG_IsOK(res1)) {
32532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32533 }
32534 arg1 = reinterpret_cast< wxWindow * >(argp1);
32535 {
32536 PyThreadState* __tstate = wxPyBeginAllowThreads();
32537 (arg1)->FitInside();
32538 wxPyEndAllowThreads(__tstate);
32539 if (PyErr_Occurred()) SWIG_fail;
32540 }
32541 resultobj = SWIG_Py_Void();
32542 return resultobj;
32543 fail:
32544 return NULL;
32545 }
32546
32547
32548 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32549 PyObject *resultobj = 0;
32550 wxWindow *arg1 = (wxWindow *) 0 ;
32551 int arg2 ;
32552 int arg3 ;
32553 int arg4 = (int) -1 ;
32554 int arg5 = (int) -1 ;
32555 int arg6 = (int) -1 ;
32556 int arg7 = (int) -1 ;
32557 void *argp1 = 0 ;
32558 int res1 = 0 ;
32559 int val2 ;
32560 int ecode2 = 0 ;
32561 int val3 ;
32562 int ecode3 = 0 ;
32563 int val4 ;
32564 int ecode4 = 0 ;
32565 int val5 ;
32566 int ecode5 = 0 ;
32567 int val6 ;
32568 int ecode6 = 0 ;
32569 int val7 ;
32570 int ecode7 = 0 ;
32571 PyObject * obj0 = 0 ;
32572 PyObject * obj1 = 0 ;
32573 PyObject * obj2 = 0 ;
32574 PyObject * obj3 = 0 ;
32575 PyObject * obj4 = 0 ;
32576 PyObject * obj5 = 0 ;
32577 PyObject * obj6 = 0 ;
32578 char * kwnames[] = {
32579 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32580 };
32581
32582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32584 if (!SWIG_IsOK(res1)) {
32585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32586 }
32587 arg1 = reinterpret_cast< wxWindow * >(argp1);
32588 ecode2 = SWIG_AsVal_int(obj1, &val2);
32589 if (!SWIG_IsOK(ecode2)) {
32590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32591 }
32592 arg2 = static_cast< int >(val2);
32593 ecode3 = SWIG_AsVal_int(obj2, &val3);
32594 if (!SWIG_IsOK(ecode3)) {
32595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32596 }
32597 arg3 = static_cast< int >(val3);
32598 if (obj3) {
32599 ecode4 = SWIG_AsVal_int(obj3, &val4);
32600 if (!SWIG_IsOK(ecode4)) {
32601 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32602 }
32603 arg4 = static_cast< int >(val4);
32604 }
32605 if (obj4) {
32606 ecode5 = SWIG_AsVal_int(obj4, &val5);
32607 if (!SWIG_IsOK(ecode5)) {
32608 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32609 }
32610 arg5 = static_cast< int >(val5);
32611 }
32612 if (obj5) {
32613 ecode6 = SWIG_AsVal_int(obj5, &val6);
32614 if (!SWIG_IsOK(ecode6)) {
32615 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32616 }
32617 arg6 = static_cast< int >(val6);
32618 }
32619 if (obj6) {
32620 ecode7 = SWIG_AsVal_int(obj6, &val7);
32621 if (!SWIG_IsOK(ecode7)) {
32622 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32623 }
32624 arg7 = static_cast< int >(val7);
32625 }
32626 {
32627 PyThreadState* __tstate = wxPyBeginAllowThreads();
32628 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32629 wxPyEndAllowThreads(__tstate);
32630 if (PyErr_Occurred()) SWIG_fail;
32631 }
32632 resultobj = SWIG_Py_Void();
32633 return resultobj;
32634 fail:
32635 return NULL;
32636 }
32637
32638
32639 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32640 PyObject *resultobj = 0;
32641 wxWindow *arg1 = (wxWindow *) 0 ;
32642 wxSize *arg2 = 0 ;
32643 wxSize const &arg3_defvalue = wxDefaultSize ;
32644 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32645 wxSize const &arg4_defvalue = wxDefaultSize ;
32646 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32647 void *argp1 = 0 ;
32648 int res1 = 0 ;
32649 wxSize temp2 ;
32650 wxSize temp3 ;
32651 wxSize temp4 ;
32652 PyObject * obj0 = 0 ;
32653 PyObject * obj1 = 0 ;
32654 PyObject * obj2 = 0 ;
32655 PyObject * obj3 = 0 ;
32656 char * kwnames[] = {
32657 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32658 };
32659
32660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32662 if (!SWIG_IsOK(res1)) {
32663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32664 }
32665 arg1 = reinterpret_cast< wxWindow * >(argp1);
32666 {
32667 arg2 = &temp2;
32668 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32669 }
32670 if (obj2) {
32671 {
32672 arg3 = &temp3;
32673 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32674 }
32675 }
32676 if (obj3) {
32677 {
32678 arg4 = &temp4;
32679 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32680 }
32681 }
32682 {
32683 PyThreadState* __tstate = wxPyBeginAllowThreads();
32684 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32685 wxPyEndAllowThreads(__tstate);
32686 if (PyErr_Occurred()) SWIG_fail;
32687 }
32688 resultobj = SWIG_Py_Void();
32689 return resultobj;
32690 fail:
32691 return NULL;
32692 }
32693
32694
32695 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32696 PyObject *resultobj = 0;
32697 wxWindow *arg1 = (wxWindow *) 0 ;
32698 int arg2 ;
32699 int arg3 ;
32700 int arg4 = (int) -1 ;
32701 int arg5 = (int) -1 ;
32702 void *argp1 = 0 ;
32703 int res1 = 0 ;
32704 int val2 ;
32705 int ecode2 = 0 ;
32706 int val3 ;
32707 int ecode3 = 0 ;
32708 int val4 ;
32709 int ecode4 = 0 ;
32710 int val5 ;
32711 int ecode5 = 0 ;
32712 PyObject * obj0 = 0 ;
32713 PyObject * obj1 = 0 ;
32714 PyObject * obj2 = 0 ;
32715 PyObject * obj3 = 0 ;
32716 PyObject * obj4 = 0 ;
32717 char * kwnames[] = {
32718 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32719 };
32720
32721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32723 if (!SWIG_IsOK(res1)) {
32724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32725 }
32726 arg1 = reinterpret_cast< wxWindow * >(argp1);
32727 ecode2 = SWIG_AsVal_int(obj1, &val2);
32728 if (!SWIG_IsOK(ecode2)) {
32729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32730 }
32731 arg2 = static_cast< int >(val2);
32732 ecode3 = SWIG_AsVal_int(obj2, &val3);
32733 if (!SWIG_IsOK(ecode3)) {
32734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32735 }
32736 arg3 = static_cast< int >(val3);
32737 if (obj3) {
32738 ecode4 = SWIG_AsVal_int(obj3, &val4);
32739 if (!SWIG_IsOK(ecode4)) {
32740 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32741 }
32742 arg4 = static_cast< int >(val4);
32743 }
32744 if (obj4) {
32745 ecode5 = SWIG_AsVal_int(obj4, &val5);
32746 if (!SWIG_IsOK(ecode5)) {
32747 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32748 }
32749 arg5 = static_cast< int >(val5);
32750 }
32751 {
32752 PyThreadState* __tstate = wxPyBeginAllowThreads();
32753 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32754 wxPyEndAllowThreads(__tstate);
32755 if (PyErr_Occurred()) SWIG_fail;
32756 }
32757 resultobj = SWIG_Py_Void();
32758 return resultobj;
32759 fail:
32760 return NULL;
32761 }
32762
32763
32764 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32765 PyObject *resultobj = 0;
32766 wxWindow *arg1 = (wxWindow *) 0 ;
32767 wxSize *arg2 = 0 ;
32768 wxSize const &arg3_defvalue = wxDefaultSize ;
32769 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32770 void *argp1 = 0 ;
32771 int res1 = 0 ;
32772 wxSize temp2 ;
32773 wxSize temp3 ;
32774 PyObject * obj0 = 0 ;
32775 PyObject * obj1 = 0 ;
32776 PyObject * obj2 = 0 ;
32777 char * kwnames[] = {
32778 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32779 };
32780
32781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32783 if (!SWIG_IsOK(res1)) {
32784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32785 }
32786 arg1 = reinterpret_cast< wxWindow * >(argp1);
32787 {
32788 arg2 = &temp2;
32789 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32790 }
32791 if (obj2) {
32792 {
32793 arg3 = &temp3;
32794 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32795 }
32796 }
32797 {
32798 PyThreadState* __tstate = wxPyBeginAllowThreads();
32799 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32800 wxPyEndAllowThreads(__tstate);
32801 if (PyErr_Occurred()) SWIG_fail;
32802 }
32803 resultobj = SWIG_Py_Void();
32804 return resultobj;
32805 fail:
32806 return NULL;
32807 }
32808
32809
32810 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32811 PyObject *resultobj = 0;
32812 wxWindow *arg1 = (wxWindow *) 0 ;
32813 wxSize result;
32814 void *argp1 = 0 ;
32815 int res1 = 0 ;
32816 PyObject *swig_obj[1] ;
32817
32818 if (!args) SWIG_fail;
32819 swig_obj[0] = args;
32820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32821 if (!SWIG_IsOK(res1)) {
32822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32823 }
32824 arg1 = reinterpret_cast< wxWindow * >(argp1);
32825 {
32826 PyThreadState* __tstate = wxPyBeginAllowThreads();
32827 result = ((wxWindow const *)arg1)->GetMaxSize();
32828 wxPyEndAllowThreads(__tstate);
32829 if (PyErr_Occurred()) SWIG_fail;
32830 }
32831 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32832 return resultobj;
32833 fail:
32834 return NULL;
32835 }
32836
32837
32838 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32839 PyObject *resultobj = 0;
32840 wxWindow *arg1 = (wxWindow *) 0 ;
32841 wxSize result;
32842 void *argp1 = 0 ;
32843 int res1 = 0 ;
32844 PyObject *swig_obj[1] ;
32845
32846 if (!args) SWIG_fail;
32847 swig_obj[0] = args;
32848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32849 if (!SWIG_IsOK(res1)) {
32850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32851 }
32852 arg1 = reinterpret_cast< wxWindow * >(argp1);
32853 {
32854 PyThreadState* __tstate = wxPyBeginAllowThreads();
32855 result = ((wxWindow const *)arg1)->GetMinSize();
32856 wxPyEndAllowThreads(__tstate);
32857 if (PyErr_Occurred()) SWIG_fail;
32858 }
32859 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32860 return resultobj;
32861 fail:
32862 return NULL;
32863 }
32864
32865
32866 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32867 PyObject *resultobj = 0;
32868 wxWindow *arg1 = (wxWindow *) 0 ;
32869 wxSize *arg2 = 0 ;
32870 void *argp1 = 0 ;
32871 int res1 = 0 ;
32872 wxSize temp2 ;
32873 PyObject * obj0 = 0 ;
32874 PyObject * obj1 = 0 ;
32875 char * kwnames[] = {
32876 (char *) "self",(char *) "minSize", NULL
32877 };
32878
32879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32881 if (!SWIG_IsOK(res1)) {
32882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32883 }
32884 arg1 = reinterpret_cast< wxWindow * >(argp1);
32885 {
32886 arg2 = &temp2;
32887 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32888 }
32889 {
32890 PyThreadState* __tstate = wxPyBeginAllowThreads();
32891 (arg1)->SetMinSize((wxSize const &)*arg2);
32892 wxPyEndAllowThreads(__tstate);
32893 if (PyErr_Occurred()) SWIG_fail;
32894 }
32895 resultobj = SWIG_Py_Void();
32896 return resultobj;
32897 fail:
32898 return NULL;
32899 }
32900
32901
32902 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32903 PyObject *resultobj = 0;
32904 wxWindow *arg1 = (wxWindow *) 0 ;
32905 wxSize *arg2 = 0 ;
32906 void *argp1 = 0 ;
32907 int res1 = 0 ;
32908 wxSize temp2 ;
32909 PyObject * obj0 = 0 ;
32910 PyObject * obj1 = 0 ;
32911 char * kwnames[] = {
32912 (char *) "self",(char *) "maxSize", NULL
32913 };
32914
32915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32917 if (!SWIG_IsOK(res1)) {
32918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32919 }
32920 arg1 = reinterpret_cast< wxWindow * >(argp1);
32921 {
32922 arg2 = &temp2;
32923 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32924 }
32925 {
32926 PyThreadState* __tstate = wxPyBeginAllowThreads();
32927 (arg1)->SetMaxSize((wxSize const &)*arg2);
32928 wxPyEndAllowThreads(__tstate);
32929 if (PyErr_Occurred()) SWIG_fail;
32930 }
32931 resultobj = SWIG_Py_Void();
32932 return resultobj;
32933 fail:
32934 return NULL;
32935 }
32936
32937
32938 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32939 PyObject *resultobj = 0;
32940 wxWindow *arg1 = (wxWindow *) 0 ;
32941 int result;
32942 void *argp1 = 0 ;
32943 int res1 = 0 ;
32944 PyObject *swig_obj[1] ;
32945
32946 if (!args) SWIG_fail;
32947 swig_obj[0] = args;
32948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32949 if (!SWIG_IsOK(res1)) {
32950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32951 }
32952 arg1 = reinterpret_cast< wxWindow * >(argp1);
32953 {
32954 PyThreadState* __tstate = wxPyBeginAllowThreads();
32955 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32956 wxPyEndAllowThreads(__tstate);
32957 if (PyErr_Occurred()) SWIG_fail;
32958 }
32959 resultobj = SWIG_From_int(static_cast< int >(result));
32960 return resultobj;
32961 fail:
32962 return NULL;
32963 }
32964
32965
32966 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32967 PyObject *resultobj = 0;
32968 wxWindow *arg1 = (wxWindow *) 0 ;
32969 int result;
32970 void *argp1 = 0 ;
32971 int res1 = 0 ;
32972 PyObject *swig_obj[1] ;
32973
32974 if (!args) SWIG_fail;
32975 swig_obj[0] = args;
32976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32977 if (!SWIG_IsOK(res1)) {
32978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32979 }
32980 arg1 = reinterpret_cast< wxWindow * >(argp1);
32981 {
32982 PyThreadState* __tstate = wxPyBeginAllowThreads();
32983 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32984 wxPyEndAllowThreads(__tstate);
32985 if (PyErr_Occurred()) SWIG_fail;
32986 }
32987 resultobj = SWIG_From_int(static_cast< int >(result));
32988 return resultobj;
32989 fail:
32990 return NULL;
32991 }
32992
32993
32994 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32995 PyObject *resultobj = 0;
32996 wxWindow *arg1 = (wxWindow *) 0 ;
32997 int result;
32998 void *argp1 = 0 ;
32999 int res1 = 0 ;
33000 PyObject *swig_obj[1] ;
33001
33002 if (!args) SWIG_fail;
33003 swig_obj[0] = args;
33004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33005 if (!SWIG_IsOK(res1)) {
33006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33007 }
33008 arg1 = reinterpret_cast< wxWindow * >(argp1);
33009 {
33010 PyThreadState* __tstate = wxPyBeginAllowThreads();
33011 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
33012 wxPyEndAllowThreads(__tstate);
33013 if (PyErr_Occurred()) SWIG_fail;
33014 }
33015 resultobj = SWIG_From_int(static_cast< int >(result));
33016 return resultobj;
33017 fail:
33018 return NULL;
33019 }
33020
33021
33022 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33023 PyObject *resultobj = 0;
33024 wxWindow *arg1 = (wxWindow *) 0 ;
33025 int result;
33026 void *argp1 = 0 ;
33027 int res1 = 0 ;
33028 PyObject *swig_obj[1] ;
33029
33030 if (!args) SWIG_fail;
33031 swig_obj[0] = args;
33032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33033 if (!SWIG_IsOK(res1)) {
33034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33035 }
33036 arg1 = reinterpret_cast< wxWindow * >(argp1);
33037 {
33038 PyThreadState* __tstate = wxPyBeginAllowThreads();
33039 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
33040 wxPyEndAllowThreads(__tstate);
33041 if (PyErr_Occurred()) SWIG_fail;
33042 }
33043 resultobj = SWIG_From_int(static_cast< int >(result));
33044 return resultobj;
33045 fail:
33046 return NULL;
33047 }
33048
33049
33050 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33051 PyObject *resultobj = 0;
33052 wxWindow *arg1 = (wxWindow *) 0 ;
33053 wxSize *arg2 = 0 ;
33054 void *argp1 = 0 ;
33055 int res1 = 0 ;
33056 wxSize temp2 ;
33057 PyObject * obj0 = 0 ;
33058 PyObject * obj1 = 0 ;
33059 char * kwnames[] = {
33060 (char *) "self",(char *) "size", NULL
33061 };
33062
33063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
33064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33065 if (!SWIG_IsOK(res1)) {
33066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33067 }
33068 arg1 = reinterpret_cast< wxWindow * >(argp1);
33069 {
33070 arg2 = &temp2;
33071 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33072 }
33073 {
33074 PyThreadState* __tstate = wxPyBeginAllowThreads();
33075 (arg1)->SetVirtualSize((wxSize const &)*arg2);
33076 wxPyEndAllowThreads(__tstate);
33077 if (PyErr_Occurred()) SWIG_fail;
33078 }
33079 resultobj = SWIG_Py_Void();
33080 return resultobj;
33081 fail:
33082 return NULL;
33083 }
33084
33085
33086 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33087 PyObject *resultobj = 0;
33088 wxWindow *arg1 = (wxWindow *) 0 ;
33089 int arg2 ;
33090 int arg3 ;
33091 void *argp1 = 0 ;
33092 int res1 = 0 ;
33093 int val2 ;
33094 int ecode2 = 0 ;
33095 int val3 ;
33096 int ecode3 = 0 ;
33097 PyObject * obj0 = 0 ;
33098 PyObject * obj1 = 0 ;
33099 PyObject * obj2 = 0 ;
33100 char * kwnames[] = {
33101 (char *) "self",(char *) "w",(char *) "h", NULL
33102 };
33103
33104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33106 if (!SWIG_IsOK(res1)) {
33107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33108 }
33109 arg1 = reinterpret_cast< wxWindow * >(argp1);
33110 ecode2 = SWIG_AsVal_int(obj1, &val2);
33111 if (!SWIG_IsOK(ecode2)) {
33112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
33113 }
33114 arg2 = static_cast< int >(val2);
33115 ecode3 = SWIG_AsVal_int(obj2, &val3);
33116 if (!SWIG_IsOK(ecode3)) {
33117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
33118 }
33119 arg3 = static_cast< int >(val3);
33120 {
33121 PyThreadState* __tstate = wxPyBeginAllowThreads();
33122 (arg1)->SetVirtualSize(arg2,arg3);
33123 wxPyEndAllowThreads(__tstate);
33124 if (PyErr_Occurred()) SWIG_fail;
33125 }
33126 resultobj = SWIG_Py_Void();
33127 return resultobj;
33128 fail:
33129 return NULL;
33130 }
33131
33132
33133 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33134 PyObject *resultobj = 0;
33135 wxWindow *arg1 = (wxWindow *) 0 ;
33136 wxSize result;
33137 void *argp1 = 0 ;
33138 int res1 = 0 ;
33139 PyObject *swig_obj[1] ;
33140
33141 if (!args) SWIG_fail;
33142 swig_obj[0] = args;
33143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33144 if (!SWIG_IsOK(res1)) {
33145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33146 }
33147 arg1 = reinterpret_cast< wxWindow * >(argp1);
33148 {
33149 PyThreadState* __tstate = wxPyBeginAllowThreads();
33150 result = ((wxWindow const *)arg1)->GetVirtualSize();
33151 wxPyEndAllowThreads(__tstate);
33152 if (PyErr_Occurred()) SWIG_fail;
33153 }
33154 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33155 return resultobj;
33156 fail:
33157 return NULL;
33158 }
33159
33160
33161 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33162 PyObject *resultobj = 0;
33163 wxWindow *arg1 = (wxWindow *) 0 ;
33164 int *arg2 = (int *) 0 ;
33165 int *arg3 = (int *) 0 ;
33166 void *argp1 = 0 ;
33167 int res1 = 0 ;
33168 int temp2 ;
33169 int res2 = SWIG_TMPOBJ ;
33170 int temp3 ;
33171 int res3 = SWIG_TMPOBJ ;
33172 PyObject *swig_obj[1] ;
33173
33174 arg2 = &temp2;
33175 arg3 = &temp3;
33176 if (!args) SWIG_fail;
33177 swig_obj[0] = args;
33178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33179 if (!SWIG_IsOK(res1)) {
33180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
33181 }
33182 arg1 = reinterpret_cast< wxWindow * >(argp1);
33183 {
33184 PyThreadState* __tstate = wxPyBeginAllowThreads();
33185 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
33186 wxPyEndAllowThreads(__tstate);
33187 if (PyErr_Occurred()) SWIG_fail;
33188 }
33189 resultobj = SWIG_Py_Void();
33190 if (SWIG_IsTmpObj(res2)) {
33191 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
33192 } else {
33193 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33194 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
33195 }
33196 if (SWIG_IsTmpObj(res3)) {
33197 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
33198 } else {
33199 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33200 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
33201 }
33202 return resultobj;
33203 fail:
33204 return NULL;
33205 }
33206
33207
33208 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33209 PyObject *resultobj = 0;
33210 wxWindow *arg1 = (wxWindow *) 0 ;
33211 wxSize result;
33212 void *argp1 = 0 ;
33213 int res1 = 0 ;
33214 PyObject *swig_obj[1] ;
33215
33216 if (!args) SWIG_fail;
33217 swig_obj[0] = args;
33218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33219 if (!SWIG_IsOK(res1)) {
33220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33221 }
33222 arg1 = reinterpret_cast< wxWindow * >(argp1);
33223 {
33224 PyThreadState* __tstate = wxPyBeginAllowThreads();
33225 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
33226 wxPyEndAllowThreads(__tstate);
33227 if (PyErr_Occurred()) SWIG_fail;
33228 }
33229 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33230 return resultobj;
33231 fail:
33232 return NULL;
33233 }
33234
33235
33236 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33237 PyObject *resultobj = 0;
33238 wxWindow *arg1 = (wxWindow *) 0 ;
33239 bool arg2 = (bool) true ;
33240 bool result;
33241 void *argp1 = 0 ;
33242 int res1 = 0 ;
33243 bool val2 ;
33244 int ecode2 = 0 ;
33245 PyObject * obj0 = 0 ;
33246 PyObject * obj1 = 0 ;
33247 char * kwnames[] = {
33248 (char *) "self",(char *) "show", NULL
33249 };
33250
33251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
33252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33253 if (!SWIG_IsOK(res1)) {
33254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
33255 }
33256 arg1 = reinterpret_cast< wxWindow * >(argp1);
33257 if (obj1) {
33258 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33259 if (!SWIG_IsOK(ecode2)) {
33260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
33261 }
33262 arg2 = static_cast< bool >(val2);
33263 }
33264 {
33265 PyThreadState* __tstate = wxPyBeginAllowThreads();
33266 result = (bool)(arg1)->Show(arg2);
33267 wxPyEndAllowThreads(__tstate);
33268 if (PyErr_Occurred()) SWIG_fail;
33269 }
33270 {
33271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33272 }
33273 return resultobj;
33274 fail:
33275 return NULL;
33276 }
33277
33278
33279 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33280 PyObject *resultobj = 0;
33281 wxWindow *arg1 = (wxWindow *) 0 ;
33282 bool result;
33283 void *argp1 = 0 ;
33284 int res1 = 0 ;
33285 PyObject *swig_obj[1] ;
33286
33287 if (!args) SWIG_fail;
33288 swig_obj[0] = args;
33289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33290 if (!SWIG_IsOK(res1)) {
33291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
33292 }
33293 arg1 = reinterpret_cast< wxWindow * >(argp1);
33294 {
33295 PyThreadState* __tstate = wxPyBeginAllowThreads();
33296 result = (bool)(arg1)->Hide();
33297 wxPyEndAllowThreads(__tstate);
33298 if (PyErr_Occurred()) SWIG_fail;
33299 }
33300 {
33301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33302 }
33303 return resultobj;
33304 fail:
33305 return NULL;
33306 }
33307
33308
33309 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33310 PyObject *resultobj = 0;
33311 wxWindow *arg1 = (wxWindow *) 0 ;
33312 bool arg2 = (bool) true ;
33313 bool result;
33314 void *argp1 = 0 ;
33315 int res1 = 0 ;
33316 bool val2 ;
33317 int ecode2 = 0 ;
33318 PyObject * obj0 = 0 ;
33319 PyObject * obj1 = 0 ;
33320 char * kwnames[] = {
33321 (char *) "self",(char *) "enable", NULL
33322 };
33323
33324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
33325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33326 if (!SWIG_IsOK(res1)) {
33327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
33328 }
33329 arg1 = reinterpret_cast< wxWindow * >(argp1);
33330 if (obj1) {
33331 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33332 if (!SWIG_IsOK(ecode2)) {
33333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
33334 }
33335 arg2 = static_cast< bool >(val2);
33336 }
33337 {
33338 PyThreadState* __tstate = wxPyBeginAllowThreads();
33339 result = (bool)(arg1)->Enable(arg2);
33340 wxPyEndAllowThreads(__tstate);
33341 if (PyErr_Occurred()) SWIG_fail;
33342 }
33343 {
33344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33345 }
33346 return resultobj;
33347 fail:
33348 return NULL;
33349 }
33350
33351
33352 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33353 PyObject *resultobj = 0;
33354 wxWindow *arg1 = (wxWindow *) 0 ;
33355 bool result;
33356 void *argp1 = 0 ;
33357 int res1 = 0 ;
33358 PyObject *swig_obj[1] ;
33359
33360 if (!args) SWIG_fail;
33361 swig_obj[0] = args;
33362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33363 if (!SWIG_IsOK(res1)) {
33364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
33365 }
33366 arg1 = reinterpret_cast< wxWindow * >(argp1);
33367 {
33368 PyThreadState* __tstate = wxPyBeginAllowThreads();
33369 result = (bool)(arg1)->Disable();
33370 wxPyEndAllowThreads(__tstate);
33371 if (PyErr_Occurred()) SWIG_fail;
33372 }
33373 {
33374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33375 }
33376 return resultobj;
33377 fail:
33378 return NULL;
33379 }
33380
33381
33382 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33383 PyObject *resultobj = 0;
33384 wxWindow *arg1 = (wxWindow *) 0 ;
33385 bool result;
33386 void *argp1 = 0 ;
33387 int res1 = 0 ;
33388 PyObject *swig_obj[1] ;
33389
33390 if (!args) SWIG_fail;
33391 swig_obj[0] = args;
33392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33393 if (!SWIG_IsOK(res1)) {
33394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
33395 }
33396 arg1 = reinterpret_cast< wxWindow * >(argp1);
33397 {
33398 PyThreadState* __tstate = wxPyBeginAllowThreads();
33399 result = (bool)((wxWindow const *)arg1)->IsShown();
33400 wxPyEndAllowThreads(__tstate);
33401 if (PyErr_Occurred()) SWIG_fail;
33402 }
33403 {
33404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33405 }
33406 return resultobj;
33407 fail:
33408 return NULL;
33409 }
33410
33411
33412 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33413 PyObject *resultobj = 0;
33414 wxWindow *arg1 = (wxWindow *) 0 ;
33415 bool result;
33416 void *argp1 = 0 ;
33417 int res1 = 0 ;
33418 PyObject *swig_obj[1] ;
33419
33420 if (!args) SWIG_fail;
33421 swig_obj[0] = args;
33422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33423 if (!SWIG_IsOK(res1)) {
33424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33425 }
33426 arg1 = reinterpret_cast< wxWindow * >(argp1);
33427 {
33428 PyThreadState* __tstate = wxPyBeginAllowThreads();
33429 result = (bool)((wxWindow const *)arg1)->IsEnabled();
33430 wxPyEndAllowThreads(__tstate);
33431 if (PyErr_Occurred()) SWIG_fail;
33432 }
33433 {
33434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33435 }
33436 return resultobj;
33437 fail:
33438 return NULL;
33439 }
33440
33441
33442 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33443 PyObject *resultobj = 0;
33444 wxWindow *arg1 = (wxWindow *) 0 ;
33445 bool result;
33446 void *argp1 = 0 ;
33447 int res1 = 0 ;
33448 PyObject *swig_obj[1] ;
33449
33450 if (!args) SWIG_fail;
33451 swig_obj[0] = args;
33452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33453 if (!SWIG_IsOK(res1)) {
33454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33455 }
33456 arg1 = reinterpret_cast< wxWindow * >(argp1);
33457 {
33458 PyThreadState* __tstate = wxPyBeginAllowThreads();
33459 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33460 wxPyEndAllowThreads(__tstate);
33461 if (PyErr_Occurred()) SWIG_fail;
33462 }
33463 {
33464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33465 }
33466 return resultobj;
33467 fail:
33468 return NULL;
33469 }
33470
33471
33472 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33473 PyObject *resultobj = 0;
33474 wxWindow *arg1 = (wxWindow *) 0 ;
33475 long arg2 ;
33476 void *argp1 = 0 ;
33477 int res1 = 0 ;
33478 long val2 ;
33479 int ecode2 = 0 ;
33480 PyObject * obj0 = 0 ;
33481 PyObject * obj1 = 0 ;
33482 char * kwnames[] = {
33483 (char *) "self",(char *) "style", NULL
33484 };
33485
33486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33488 if (!SWIG_IsOK(res1)) {
33489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33490 }
33491 arg1 = reinterpret_cast< wxWindow * >(argp1);
33492 ecode2 = SWIG_AsVal_long(obj1, &val2);
33493 if (!SWIG_IsOK(ecode2)) {
33494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33495 }
33496 arg2 = static_cast< long >(val2);
33497 {
33498 PyThreadState* __tstate = wxPyBeginAllowThreads();
33499 (arg1)->SetWindowStyleFlag(arg2);
33500 wxPyEndAllowThreads(__tstate);
33501 if (PyErr_Occurred()) SWIG_fail;
33502 }
33503 resultobj = SWIG_Py_Void();
33504 return resultobj;
33505 fail:
33506 return NULL;
33507 }
33508
33509
33510 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33511 PyObject *resultobj = 0;
33512 wxWindow *arg1 = (wxWindow *) 0 ;
33513 long result;
33514 void *argp1 = 0 ;
33515 int res1 = 0 ;
33516 PyObject *swig_obj[1] ;
33517
33518 if (!args) SWIG_fail;
33519 swig_obj[0] = args;
33520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33521 if (!SWIG_IsOK(res1)) {
33522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33523 }
33524 arg1 = reinterpret_cast< wxWindow * >(argp1);
33525 {
33526 PyThreadState* __tstate = wxPyBeginAllowThreads();
33527 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33528 wxPyEndAllowThreads(__tstate);
33529 if (PyErr_Occurred()) SWIG_fail;
33530 }
33531 resultobj = SWIG_From_long(static_cast< long >(result));
33532 return resultobj;
33533 fail:
33534 return NULL;
33535 }
33536
33537
33538 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33539 PyObject *resultobj = 0;
33540 wxWindow *arg1 = (wxWindow *) 0 ;
33541 int arg2 ;
33542 bool result;
33543 void *argp1 = 0 ;
33544 int res1 = 0 ;
33545 int val2 ;
33546 int ecode2 = 0 ;
33547 PyObject * obj0 = 0 ;
33548 PyObject * obj1 = 0 ;
33549 char * kwnames[] = {
33550 (char *) "self",(char *) "flag", NULL
33551 };
33552
33553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33555 if (!SWIG_IsOK(res1)) {
33556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33557 }
33558 arg1 = reinterpret_cast< wxWindow * >(argp1);
33559 ecode2 = SWIG_AsVal_int(obj1, &val2);
33560 if (!SWIG_IsOK(ecode2)) {
33561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33562 }
33563 arg2 = static_cast< int >(val2);
33564 {
33565 PyThreadState* __tstate = wxPyBeginAllowThreads();
33566 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33567 wxPyEndAllowThreads(__tstate);
33568 if (PyErr_Occurred()) SWIG_fail;
33569 }
33570 {
33571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33572 }
33573 return resultobj;
33574 fail:
33575 return NULL;
33576 }
33577
33578
33579 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33580 PyObject *resultobj = 0;
33581 wxWindow *arg1 = (wxWindow *) 0 ;
33582 bool result;
33583 void *argp1 = 0 ;
33584 int res1 = 0 ;
33585 PyObject *swig_obj[1] ;
33586
33587 if (!args) SWIG_fail;
33588 swig_obj[0] = args;
33589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33590 if (!SWIG_IsOK(res1)) {
33591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33592 }
33593 arg1 = reinterpret_cast< wxWindow * >(argp1);
33594 {
33595 PyThreadState* __tstate = wxPyBeginAllowThreads();
33596 result = (bool)((wxWindow const *)arg1)->IsRetained();
33597 wxPyEndAllowThreads(__tstate);
33598 if (PyErr_Occurred()) SWIG_fail;
33599 }
33600 {
33601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33602 }
33603 return resultobj;
33604 fail:
33605 return NULL;
33606 }
33607
33608
33609 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33610 PyObject *resultobj = 0;
33611 wxWindow *arg1 = (wxWindow *) 0 ;
33612 long arg2 ;
33613 void *argp1 = 0 ;
33614 int res1 = 0 ;
33615 long val2 ;
33616 int ecode2 = 0 ;
33617 PyObject * obj0 = 0 ;
33618 PyObject * obj1 = 0 ;
33619 char * kwnames[] = {
33620 (char *) "self",(char *) "exStyle", NULL
33621 };
33622
33623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33625 if (!SWIG_IsOK(res1)) {
33626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33627 }
33628 arg1 = reinterpret_cast< wxWindow * >(argp1);
33629 ecode2 = SWIG_AsVal_long(obj1, &val2);
33630 if (!SWIG_IsOK(ecode2)) {
33631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33632 }
33633 arg2 = static_cast< long >(val2);
33634 {
33635 PyThreadState* __tstate = wxPyBeginAllowThreads();
33636 (arg1)->SetExtraStyle(arg2);
33637 wxPyEndAllowThreads(__tstate);
33638 if (PyErr_Occurred()) SWIG_fail;
33639 }
33640 resultobj = SWIG_Py_Void();
33641 return resultobj;
33642 fail:
33643 return NULL;
33644 }
33645
33646
33647 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33648 PyObject *resultobj = 0;
33649 wxWindow *arg1 = (wxWindow *) 0 ;
33650 long result;
33651 void *argp1 = 0 ;
33652 int res1 = 0 ;
33653 PyObject *swig_obj[1] ;
33654
33655 if (!args) SWIG_fail;
33656 swig_obj[0] = args;
33657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33658 if (!SWIG_IsOK(res1)) {
33659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33660 }
33661 arg1 = reinterpret_cast< wxWindow * >(argp1);
33662 {
33663 PyThreadState* __tstate = wxPyBeginAllowThreads();
33664 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33665 wxPyEndAllowThreads(__tstate);
33666 if (PyErr_Occurred()) SWIG_fail;
33667 }
33668 resultobj = SWIG_From_long(static_cast< long >(result));
33669 return resultobj;
33670 fail:
33671 return NULL;
33672 }
33673
33674
33675 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33676 PyObject *resultobj = 0;
33677 wxWindow *arg1 = (wxWindow *) 0 ;
33678 bool arg2 = (bool) true ;
33679 void *argp1 = 0 ;
33680 int res1 = 0 ;
33681 bool val2 ;
33682 int ecode2 = 0 ;
33683 PyObject * obj0 = 0 ;
33684 PyObject * obj1 = 0 ;
33685 char * kwnames[] = {
33686 (char *) "self",(char *) "modal", NULL
33687 };
33688
33689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33691 if (!SWIG_IsOK(res1)) {
33692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33693 }
33694 arg1 = reinterpret_cast< wxWindow * >(argp1);
33695 if (obj1) {
33696 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33697 if (!SWIG_IsOK(ecode2)) {
33698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33699 }
33700 arg2 = static_cast< bool >(val2);
33701 }
33702 {
33703 PyThreadState* __tstate = wxPyBeginAllowThreads();
33704 (arg1)->MakeModal(arg2);
33705 wxPyEndAllowThreads(__tstate);
33706 if (PyErr_Occurred()) SWIG_fail;
33707 }
33708 resultobj = SWIG_Py_Void();
33709 return resultobj;
33710 fail:
33711 return NULL;
33712 }
33713
33714
33715 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33716 PyObject *resultobj = 0;
33717 wxWindow *arg1 = (wxWindow *) 0 ;
33718 bool arg2 ;
33719 void *argp1 = 0 ;
33720 int res1 = 0 ;
33721 bool val2 ;
33722 int ecode2 = 0 ;
33723 PyObject * obj0 = 0 ;
33724 PyObject * obj1 = 0 ;
33725 char * kwnames[] = {
33726 (char *) "self",(char *) "enableTheme", NULL
33727 };
33728
33729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33731 if (!SWIG_IsOK(res1)) {
33732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33733 }
33734 arg1 = reinterpret_cast< wxWindow * >(argp1);
33735 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33736 if (!SWIG_IsOK(ecode2)) {
33737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33738 }
33739 arg2 = static_cast< bool >(val2);
33740 {
33741 PyThreadState* __tstate = wxPyBeginAllowThreads();
33742 (arg1)->SetThemeEnabled(arg2);
33743 wxPyEndAllowThreads(__tstate);
33744 if (PyErr_Occurred()) SWIG_fail;
33745 }
33746 resultobj = SWIG_Py_Void();
33747 return resultobj;
33748 fail:
33749 return NULL;
33750 }
33751
33752
33753 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33754 PyObject *resultobj = 0;
33755 wxWindow *arg1 = (wxWindow *) 0 ;
33756 bool result;
33757 void *argp1 = 0 ;
33758 int res1 = 0 ;
33759 PyObject *swig_obj[1] ;
33760
33761 if (!args) SWIG_fail;
33762 swig_obj[0] = args;
33763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33764 if (!SWIG_IsOK(res1)) {
33765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33766 }
33767 arg1 = reinterpret_cast< wxWindow * >(argp1);
33768 {
33769 PyThreadState* __tstate = wxPyBeginAllowThreads();
33770 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33771 wxPyEndAllowThreads(__tstate);
33772 if (PyErr_Occurred()) SWIG_fail;
33773 }
33774 {
33775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33776 }
33777 return resultobj;
33778 fail:
33779 return NULL;
33780 }
33781
33782
33783 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33784 PyObject *resultobj = 0;
33785 wxWindow *arg1 = (wxWindow *) 0 ;
33786 void *argp1 = 0 ;
33787 int res1 = 0 ;
33788 PyObject *swig_obj[1] ;
33789
33790 if (!args) SWIG_fail;
33791 swig_obj[0] = args;
33792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33793 if (!SWIG_IsOK(res1)) {
33794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33795 }
33796 arg1 = reinterpret_cast< wxWindow * >(argp1);
33797 {
33798 PyThreadState* __tstate = wxPyBeginAllowThreads();
33799 (arg1)->SetFocus();
33800 wxPyEndAllowThreads(__tstate);
33801 if (PyErr_Occurred()) SWIG_fail;
33802 }
33803 resultobj = SWIG_Py_Void();
33804 return resultobj;
33805 fail:
33806 return NULL;
33807 }
33808
33809
33810 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33811 PyObject *resultobj = 0;
33812 wxWindow *arg1 = (wxWindow *) 0 ;
33813 void *argp1 = 0 ;
33814 int res1 = 0 ;
33815 PyObject *swig_obj[1] ;
33816
33817 if (!args) SWIG_fail;
33818 swig_obj[0] = args;
33819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33820 if (!SWIG_IsOK(res1)) {
33821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33822 }
33823 arg1 = reinterpret_cast< wxWindow * >(argp1);
33824 {
33825 PyThreadState* __tstate = wxPyBeginAllowThreads();
33826 (arg1)->SetFocusFromKbd();
33827 wxPyEndAllowThreads(__tstate);
33828 if (PyErr_Occurred()) SWIG_fail;
33829 }
33830 resultobj = SWIG_Py_Void();
33831 return resultobj;
33832 fail:
33833 return NULL;
33834 }
33835
33836
33837 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33838 PyObject *resultobj = 0;
33839 wxWindow *result = 0 ;
33840
33841 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33842 {
33843 if (!wxPyCheckForApp()) SWIG_fail;
33844 PyThreadState* __tstate = wxPyBeginAllowThreads();
33845 result = (wxWindow *)wxWindow::FindFocus();
33846 wxPyEndAllowThreads(__tstate);
33847 if (PyErr_Occurred()) SWIG_fail;
33848 }
33849 {
33850 resultobj = wxPyMake_wxObject(result, 0);
33851 }
33852 return resultobj;
33853 fail:
33854 return NULL;
33855 }
33856
33857
33858 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33859 PyObject *resultobj = 0;
33860 wxWindow *arg1 = (wxWindow *) 0 ;
33861 bool result;
33862 void *argp1 = 0 ;
33863 int res1 = 0 ;
33864 PyObject *swig_obj[1] ;
33865
33866 if (!args) SWIG_fail;
33867 swig_obj[0] = args;
33868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33869 if (!SWIG_IsOK(res1)) {
33870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33871 }
33872 arg1 = reinterpret_cast< wxWindow * >(argp1);
33873 {
33874 PyThreadState* __tstate = wxPyBeginAllowThreads();
33875 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33876 wxPyEndAllowThreads(__tstate);
33877 if (PyErr_Occurred()) SWIG_fail;
33878 }
33879 {
33880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33881 }
33882 return resultobj;
33883 fail:
33884 return NULL;
33885 }
33886
33887
33888 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33889 PyObject *resultobj = 0;
33890 wxWindow *arg1 = (wxWindow *) 0 ;
33891 bool result;
33892 void *argp1 = 0 ;
33893 int res1 = 0 ;
33894 PyObject *swig_obj[1] ;
33895
33896 if (!args) SWIG_fail;
33897 swig_obj[0] = args;
33898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33899 if (!SWIG_IsOK(res1)) {
33900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33901 }
33902 arg1 = reinterpret_cast< wxWindow * >(argp1);
33903 {
33904 PyThreadState* __tstate = wxPyBeginAllowThreads();
33905 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33906 wxPyEndAllowThreads(__tstate);
33907 if (PyErr_Occurred()) SWIG_fail;
33908 }
33909 {
33910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33911 }
33912 return resultobj;
33913 fail:
33914 return NULL;
33915 }
33916
33917
33918 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33919 PyObject *resultobj = 0;
33920 wxWindow *arg1 = (wxWindow *) 0 ;
33921 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33922 bool result;
33923 void *argp1 = 0 ;
33924 int res1 = 0 ;
33925 int val2 ;
33926 int ecode2 = 0 ;
33927 PyObject * obj0 = 0 ;
33928 PyObject * obj1 = 0 ;
33929 char * kwnames[] = {
33930 (char *) "self",(char *) "flags", NULL
33931 };
33932
33933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33935 if (!SWIG_IsOK(res1)) {
33936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33937 }
33938 arg1 = reinterpret_cast< wxWindow * >(argp1);
33939 if (obj1) {
33940 ecode2 = SWIG_AsVal_int(obj1, &val2);
33941 if (!SWIG_IsOK(ecode2)) {
33942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33943 }
33944 arg2 = static_cast< int >(val2);
33945 }
33946 {
33947 PyThreadState* __tstate = wxPyBeginAllowThreads();
33948 result = (bool)(arg1)->Navigate(arg2);
33949 wxPyEndAllowThreads(__tstate);
33950 if (PyErr_Occurred()) SWIG_fail;
33951 }
33952 {
33953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33954 }
33955 return resultobj;
33956 fail:
33957 return NULL;
33958 }
33959
33960
33961 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33962 PyObject *resultobj = 0;
33963 wxWindow *arg1 = (wxWindow *) 0 ;
33964 wxWindow *arg2 = (wxWindow *) 0 ;
33965 void *argp1 = 0 ;
33966 int res1 = 0 ;
33967 void *argp2 = 0 ;
33968 int res2 = 0 ;
33969 PyObject * obj0 = 0 ;
33970 PyObject * obj1 = 0 ;
33971 char * kwnames[] = {
33972 (char *) "self",(char *) "win", NULL
33973 };
33974
33975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33977 if (!SWIG_IsOK(res1)) {
33978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33979 }
33980 arg1 = reinterpret_cast< wxWindow * >(argp1);
33981 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33982 if (!SWIG_IsOK(res2)) {
33983 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33984 }
33985 arg2 = reinterpret_cast< wxWindow * >(argp2);
33986 {
33987 PyThreadState* __tstate = wxPyBeginAllowThreads();
33988 (arg1)->MoveAfterInTabOrder(arg2);
33989 wxPyEndAllowThreads(__tstate);
33990 if (PyErr_Occurred()) SWIG_fail;
33991 }
33992 resultobj = SWIG_Py_Void();
33993 return resultobj;
33994 fail:
33995 return NULL;
33996 }
33997
33998
33999 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34000 PyObject *resultobj = 0;
34001 wxWindow *arg1 = (wxWindow *) 0 ;
34002 wxWindow *arg2 = (wxWindow *) 0 ;
34003 void *argp1 = 0 ;
34004 int res1 = 0 ;
34005 void *argp2 = 0 ;
34006 int res2 = 0 ;
34007 PyObject * obj0 = 0 ;
34008 PyObject * obj1 = 0 ;
34009 char * kwnames[] = {
34010 (char *) "self",(char *) "win", NULL
34011 };
34012
34013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34015 if (!SWIG_IsOK(res1)) {
34016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34017 }
34018 arg1 = reinterpret_cast< wxWindow * >(argp1);
34019 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34020 if (!SWIG_IsOK(res2)) {
34021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34022 }
34023 arg2 = reinterpret_cast< wxWindow * >(argp2);
34024 {
34025 PyThreadState* __tstate = wxPyBeginAllowThreads();
34026 (arg1)->MoveBeforeInTabOrder(arg2);
34027 wxPyEndAllowThreads(__tstate);
34028 if (PyErr_Occurred()) SWIG_fail;
34029 }
34030 resultobj = SWIG_Py_Void();
34031 return resultobj;
34032 fail:
34033 return NULL;
34034 }
34035
34036
34037 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34038 PyObject *resultobj = 0;
34039 wxWindow *arg1 = (wxWindow *) 0 ;
34040 PyObject *result = 0 ;
34041 void *argp1 = 0 ;
34042 int res1 = 0 ;
34043 PyObject *swig_obj[1] ;
34044
34045 if (!args) SWIG_fail;
34046 swig_obj[0] = args;
34047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34048 if (!SWIG_IsOK(res1)) {
34049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
34050 }
34051 arg1 = reinterpret_cast< wxWindow * >(argp1);
34052 {
34053 PyThreadState* __tstate = wxPyBeginAllowThreads();
34054 result = (PyObject *)wxWindow_GetChildren(arg1);
34055 wxPyEndAllowThreads(__tstate);
34056 if (PyErr_Occurred()) SWIG_fail;
34057 }
34058 resultobj = result;
34059 return resultobj;
34060 fail:
34061 return NULL;
34062 }
34063
34064
34065 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34066 PyObject *resultobj = 0;
34067 wxWindow *arg1 = (wxWindow *) 0 ;
34068 wxWindow *result = 0 ;
34069 void *argp1 = 0 ;
34070 int res1 = 0 ;
34071 PyObject *swig_obj[1] ;
34072
34073 if (!args) SWIG_fail;
34074 swig_obj[0] = args;
34075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34076 if (!SWIG_IsOK(res1)) {
34077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34078 }
34079 arg1 = reinterpret_cast< wxWindow * >(argp1);
34080 {
34081 PyThreadState* __tstate = wxPyBeginAllowThreads();
34082 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
34083 wxPyEndAllowThreads(__tstate);
34084 if (PyErr_Occurred()) SWIG_fail;
34085 }
34086 {
34087 resultobj = wxPyMake_wxObject(result, 0);
34088 }
34089 return resultobj;
34090 fail:
34091 return NULL;
34092 }
34093
34094
34095 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34096 PyObject *resultobj = 0;
34097 wxWindow *arg1 = (wxWindow *) 0 ;
34098 wxWindow *result = 0 ;
34099 void *argp1 = 0 ;
34100 int res1 = 0 ;
34101 PyObject *swig_obj[1] ;
34102
34103 if (!args) SWIG_fail;
34104 swig_obj[0] = args;
34105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34106 if (!SWIG_IsOK(res1)) {
34107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34108 }
34109 arg1 = reinterpret_cast< wxWindow * >(argp1);
34110 {
34111 PyThreadState* __tstate = wxPyBeginAllowThreads();
34112 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
34113 wxPyEndAllowThreads(__tstate);
34114 if (PyErr_Occurred()) SWIG_fail;
34115 }
34116 {
34117 resultobj = wxPyMake_wxObject(result, 0);
34118 }
34119 return resultobj;
34120 fail:
34121 return NULL;
34122 }
34123
34124
34125 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34126 PyObject *resultobj = 0;
34127 wxWindow *arg1 = (wxWindow *) 0 ;
34128 bool result;
34129 void *argp1 = 0 ;
34130 int res1 = 0 ;
34131 PyObject *swig_obj[1] ;
34132
34133 if (!args) SWIG_fail;
34134 swig_obj[0] = args;
34135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34136 if (!SWIG_IsOK(res1)) {
34137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
34138 }
34139 arg1 = reinterpret_cast< wxWindow * >(argp1);
34140 {
34141 PyThreadState* __tstate = wxPyBeginAllowThreads();
34142 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
34143 wxPyEndAllowThreads(__tstate);
34144 if (PyErr_Occurred()) SWIG_fail;
34145 }
34146 {
34147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34148 }
34149 return resultobj;
34150 fail:
34151 return NULL;
34152 }
34153
34154
34155 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34156 PyObject *resultobj = 0;
34157 wxWindow *arg1 = (wxWindow *) 0 ;
34158 wxWindow *arg2 = (wxWindow *) 0 ;
34159 bool result;
34160 void *argp1 = 0 ;
34161 int res1 = 0 ;
34162 void *argp2 = 0 ;
34163 int res2 = 0 ;
34164 PyObject * obj0 = 0 ;
34165 PyObject * obj1 = 0 ;
34166 char * kwnames[] = {
34167 (char *) "self",(char *) "newParent", NULL
34168 };
34169
34170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
34171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34172 if (!SWIG_IsOK(res1)) {
34173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
34174 }
34175 arg1 = reinterpret_cast< wxWindow * >(argp1);
34176 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34177 if (!SWIG_IsOK(res2)) {
34178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
34179 }
34180 arg2 = reinterpret_cast< wxWindow * >(argp2);
34181 {
34182 PyThreadState* __tstate = wxPyBeginAllowThreads();
34183 result = (bool)(arg1)->Reparent(arg2);
34184 wxPyEndAllowThreads(__tstate);
34185 if (PyErr_Occurred()) SWIG_fail;
34186 }
34187 {
34188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34189 }
34190 return resultobj;
34191 fail:
34192 return NULL;
34193 }
34194
34195
34196 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34197 PyObject *resultobj = 0;
34198 wxWindow *arg1 = (wxWindow *) 0 ;
34199 wxWindow *arg2 = (wxWindow *) 0 ;
34200 void *argp1 = 0 ;
34201 int res1 = 0 ;
34202 void *argp2 = 0 ;
34203 int res2 = 0 ;
34204 PyObject * obj0 = 0 ;
34205 PyObject * obj1 = 0 ;
34206 char * kwnames[] = {
34207 (char *) "self",(char *) "child", NULL
34208 };
34209
34210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
34211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34212 if (!SWIG_IsOK(res1)) {
34213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34214 }
34215 arg1 = reinterpret_cast< wxWindow * >(argp1);
34216 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34217 if (!SWIG_IsOK(res2)) {
34218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34219 }
34220 arg2 = reinterpret_cast< wxWindow * >(argp2);
34221 {
34222 PyThreadState* __tstate = wxPyBeginAllowThreads();
34223 (arg1)->AddChild(arg2);
34224 wxPyEndAllowThreads(__tstate);
34225 if (PyErr_Occurred()) SWIG_fail;
34226 }
34227 resultobj = SWIG_Py_Void();
34228 return resultobj;
34229 fail:
34230 return NULL;
34231 }
34232
34233
34234 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34235 PyObject *resultobj = 0;
34236 wxWindow *arg1 = (wxWindow *) 0 ;
34237 wxWindow *arg2 = (wxWindow *) 0 ;
34238 void *argp1 = 0 ;
34239 int res1 = 0 ;
34240 void *argp2 = 0 ;
34241 int res2 = 0 ;
34242 PyObject * obj0 = 0 ;
34243 PyObject * obj1 = 0 ;
34244 char * kwnames[] = {
34245 (char *) "self",(char *) "child", NULL
34246 };
34247
34248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
34249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34250 if (!SWIG_IsOK(res1)) {
34251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34252 }
34253 arg1 = reinterpret_cast< wxWindow * >(argp1);
34254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34255 if (!SWIG_IsOK(res2)) {
34256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34257 }
34258 arg2 = reinterpret_cast< wxWindow * >(argp2);
34259 {
34260 PyThreadState* __tstate = wxPyBeginAllowThreads();
34261 (arg1)->RemoveChild(arg2);
34262 wxPyEndAllowThreads(__tstate);
34263 if (PyErr_Occurred()) SWIG_fail;
34264 }
34265 resultobj = SWIG_Py_Void();
34266 return resultobj;
34267 fail:
34268 return NULL;
34269 }
34270
34271
34272 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34273 PyObject *resultobj = 0;
34274 wxWindow *arg1 = (wxWindow *) 0 ;
34275 bool arg2 ;
34276 void *argp1 = 0 ;
34277 int res1 = 0 ;
34278 bool val2 ;
34279 int ecode2 = 0 ;
34280 PyObject * obj0 = 0 ;
34281 PyObject * obj1 = 0 ;
34282 char * kwnames[] = {
34283 (char *) "self",(char *) "on", NULL
34284 };
34285
34286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
34287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34288 if (!SWIG_IsOK(res1)) {
34289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
34290 }
34291 arg1 = reinterpret_cast< wxWindow * >(argp1);
34292 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34293 if (!SWIG_IsOK(ecode2)) {
34294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
34295 }
34296 arg2 = static_cast< bool >(val2);
34297 {
34298 PyThreadState* __tstate = wxPyBeginAllowThreads();
34299 wxWindow_SetDoubleBuffered(arg1,arg2);
34300 wxPyEndAllowThreads(__tstate);
34301 if (PyErr_Occurred()) SWIG_fail;
34302 }
34303 resultobj = SWIG_Py_Void();
34304 return resultobj;
34305 fail:
34306 return NULL;
34307 }
34308
34309
34310 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34311 PyObject *resultobj = 0;
34312 wxWindow *arg1 = (wxWindow *) 0 ;
34313 long arg2 ;
34314 wxWindow *result = 0 ;
34315 void *argp1 = 0 ;
34316 int res1 = 0 ;
34317 long val2 ;
34318 int ecode2 = 0 ;
34319 PyObject * obj0 = 0 ;
34320 PyObject * obj1 = 0 ;
34321 char * kwnames[] = {
34322 (char *) "self",(char *) "winid", NULL
34323 };
34324
34325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
34326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34327 if (!SWIG_IsOK(res1)) {
34328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
34329 }
34330 arg1 = reinterpret_cast< wxWindow * >(argp1);
34331 ecode2 = SWIG_AsVal_long(obj1, &val2);
34332 if (!SWIG_IsOK(ecode2)) {
34333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
34334 }
34335 arg2 = static_cast< long >(val2);
34336 {
34337 PyThreadState* __tstate = wxPyBeginAllowThreads();
34338 result = (wxWindow *)(arg1)->FindWindow(arg2);
34339 wxPyEndAllowThreads(__tstate);
34340 if (PyErr_Occurred()) SWIG_fail;
34341 }
34342 {
34343 resultobj = wxPyMake_wxObject(result, 0);
34344 }
34345 return resultobj;
34346 fail:
34347 return NULL;
34348 }
34349
34350
34351 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34352 PyObject *resultobj = 0;
34353 wxWindow *arg1 = (wxWindow *) 0 ;
34354 wxString *arg2 = 0 ;
34355 wxWindow *result = 0 ;
34356 void *argp1 = 0 ;
34357 int res1 = 0 ;
34358 bool temp2 = false ;
34359 PyObject * obj0 = 0 ;
34360 PyObject * obj1 = 0 ;
34361 char * kwnames[] = {
34362 (char *) "self",(char *) "name", NULL
34363 };
34364
34365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
34366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34367 if (!SWIG_IsOK(res1)) {
34368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
34369 }
34370 arg1 = reinterpret_cast< wxWindow * >(argp1);
34371 {
34372 arg2 = wxString_in_helper(obj1);
34373 if (arg2 == NULL) SWIG_fail;
34374 temp2 = true;
34375 }
34376 {
34377 PyThreadState* __tstate = wxPyBeginAllowThreads();
34378 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
34379 wxPyEndAllowThreads(__tstate);
34380 if (PyErr_Occurred()) SWIG_fail;
34381 }
34382 {
34383 resultobj = wxPyMake_wxObject(result, 0);
34384 }
34385 {
34386 if (temp2)
34387 delete arg2;
34388 }
34389 return resultobj;
34390 fail:
34391 {
34392 if (temp2)
34393 delete arg2;
34394 }
34395 return NULL;
34396 }
34397
34398
34399 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34400 PyObject *resultobj = 0;
34401 wxWindow *arg1 = (wxWindow *) 0 ;
34402 wxEvtHandler *result = 0 ;
34403 void *argp1 = 0 ;
34404 int res1 = 0 ;
34405 PyObject *swig_obj[1] ;
34406
34407 if (!args) SWIG_fail;
34408 swig_obj[0] = args;
34409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34410 if (!SWIG_IsOK(res1)) {
34411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
34412 }
34413 arg1 = reinterpret_cast< wxWindow * >(argp1);
34414 {
34415 PyThreadState* __tstate = wxPyBeginAllowThreads();
34416 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
34417 wxPyEndAllowThreads(__tstate);
34418 if (PyErr_Occurred()) SWIG_fail;
34419 }
34420 {
34421 resultobj = wxPyMake_wxObject(result, 0);
34422 }
34423 return resultobj;
34424 fail:
34425 return NULL;
34426 }
34427
34428
34429 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34430 PyObject *resultobj = 0;
34431 wxWindow *arg1 = (wxWindow *) 0 ;
34432 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34433 void *argp1 = 0 ;
34434 int res1 = 0 ;
34435 void *argp2 = 0 ;
34436 int res2 = 0 ;
34437 PyObject * obj0 = 0 ;
34438 PyObject * obj1 = 0 ;
34439 char * kwnames[] = {
34440 (char *) "self",(char *) "handler", NULL
34441 };
34442
34443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34445 if (!SWIG_IsOK(res1)) {
34446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34447 }
34448 arg1 = reinterpret_cast< wxWindow * >(argp1);
34449 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34450 if (!SWIG_IsOK(res2)) {
34451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34452 }
34453 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34454 {
34455 PyThreadState* __tstate = wxPyBeginAllowThreads();
34456 (arg1)->SetEventHandler(arg2);
34457 wxPyEndAllowThreads(__tstate);
34458 if (PyErr_Occurred()) SWIG_fail;
34459 }
34460 resultobj = SWIG_Py_Void();
34461 return resultobj;
34462 fail:
34463 return NULL;
34464 }
34465
34466
34467 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34468 PyObject *resultobj = 0;
34469 wxWindow *arg1 = (wxWindow *) 0 ;
34470 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34471 void *argp1 = 0 ;
34472 int res1 = 0 ;
34473 void *argp2 = 0 ;
34474 int res2 = 0 ;
34475 PyObject * obj0 = 0 ;
34476 PyObject * obj1 = 0 ;
34477 char * kwnames[] = {
34478 (char *) "self",(char *) "handler", NULL
34479 };
34480
34481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34483 if (!SWIG_IsOK(res1)) {
34484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34485 }
34486 arg1 = reinterpret_cast< wxWindow * >(argp1);
34487 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34488 if (!SWIG_IsOK(res2)) {
34489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34490 }
34491 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34492 {
34493 PyThreadState* __tstate = wxPyBeginAllowThreads();
34494 (arg1)->PushEventHandler(arg2);
34495 wxPyEndAllowThreads(__tstate);
34496 if (PyErr_Occurred()) SWIG_fail;
34497 }
34498 resultobj = SWIG_Py_Void();
34499 return resultobj;
34500 fail:
34501 return NULL;
34502 }
34503
34504
34505 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34506 PyObject *resultobj = 0;
34507 wxWindow *arg1 = (wxWindow *) 0 ;
34508 bool arg2 = (bool) false ;
34509 wxEvtHandler *result = 0 ;
34510 void *argp1 = 0 ;
34511 int res1 = 0 ;
34512 bool val2 ;
34513 int ecode2 = 0 ;
34514 PyObject * obj0 = 0 ;
34515 PyObject * obj1 = 0 ;
34516 char * kwnames[] = {
34517 (char *) "self",(char *) "deleteHandler", NULL
34518 };
34519
34520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34522 if (!SWIG_IsOK(res1)) {
34523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34524 }
34525 arg1 = reinterpret_cast< wxWindow * >(argp1);
34526 if (obj1) {
34527 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34528 if (!SWIG_IsOK(ecode2)) {
34529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34530 }
34531 arg2 = static_cast< bool >(val2);
34532 }
34533 {
34534 PyThreadState* __tstate = wxPyBeginAllowThreads();
34535 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34536 wxPyEndAllowThreads(__tstate);
34537 if (PyErr_Occurred()) SWIG_fail;
34538 }
34539 {
34540 resultobj = wxPyMake_wxObject(result, 0);
34541 }
34542 return resultobj;
34543 fail:
34544 return NULL;
34545 }
34546
34547
34548 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34549 PyObject *resultobj = 0;
34550 wxWindow *arg1 = (wxWindow *) 0 ;
34551 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34552 bool result;
34553 void *argp1 = 0 ;
34554 int res1 = 0 ;
34555 void *argp2 = 0 ;
34556 int res2 = 0 ;
34557 PyObject * obj0 = 0 ;
34558 PyObject * obj1 = 0 ;
34559 char * kwnames[] = {
34560 (char *) "self",(char *) "handler", NULL
34561 };
34562
34563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34565 if (!SWIG_IsOK(res1)) {
34566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34567 }
34568 arg1 = reinterpret_cast< wxWindow * >(argp1);
34569 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34570 if (!SWIG_IsOK(res2)) {
34571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34572 }
34573 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34574 {
34575 PyThreadState* __tstate = wxPyBeginAllowThreads();
34576 result = (bool)(arg1)->RemoveEventHandler(arg2);
34577 wxPyEndAllowThreads(__tstate);
34578 if (PyErr_Occurred()) SWIG_fail;
34579 }
34580 {
34581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34582 }
34583 return resultobj;
34584 fail:
34585 return NULL;
34586 }
34587
34588
34589 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34590 PyObject *resultobj = 0;
34591 wxWindow *arg1 = (wxWindow *) 0 ;
34592 wxValidator *arg2 = 0 ;
34593 void *argp1 = 0 ;
34594 int res1 = 0 ;
34595 void *argp2 = 0 ;
34596 int res2 = 0 ;
34597 PyObject * obj0 = 0 ;
34598 PyObject * obj1 = 0 ;
34599 char * kwnames[] = {
34600 (char *) "self",(char *) "validator", NULL
34601 };
34602
34603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34605 if (!SWIG_IsOK(res1)) {
34606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34607 }
34608 arg1 = reinterpret_cast< wxWindow * >(argp1);
34609 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34610 if (!SWIG_IsOK(res2)) {
34611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34612 }
34613 if (!argp2) {
34614 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34615 }
34616 arg2 = reinterpret_cast< wxValidator * >(argp2);
34617 {
34618 PyThreadState* __tstate = wxPyBeginAllowThreads();
34619 (arg1)->SetValidator((wxValidator const &)*arg2);
34620 wxPyEndAllowThreads(__tstate);
34621 if (PyErr_Occurred()) SWIG_fail;
34622 }
34623 resultobj = SWIG_Py_Void();
34624 return resultobj;
34625 fail:
34626 return NULL;
34627 }
34628
34629
34630 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34631 PyObject *resultobj = 0;
34632 wxWindow *arg1 = (wxWindow *) 0 ;
34633 wxValidator *result = 0 ;
34634 void *argp1 = 0 ;
34635 int res1 = 0 ;
34636 PyObject *swig_obj[1] ;
34637
34638 if (!args) SWIG_fail;
34639 swig_obj[0] = args;
34640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34641 if (!SWIG_IsOK(res1)) {
34642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34643 }
34644 arg1 = reinterpret_cast< wxWindow * >(argp1);
34645 {
34646 PyThreadState* __tstate = wxPyBeginAllowThreads();
34647 result = (wxValidator *)(arg1)->GetValidator();
34648 wxPyEndAllowThreads(__tstate);
34649 if (PyErr_Occurred()) SWIG_fail;
34650 }
34651 {
34652 resultobj = wxPyMake_wxObject(result, (bool)0);
34653 }
34654 return resultobj;
34655 fail:
34656 return NULL;
34657 }
34658
34659
34660 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34661 PyObject *resultobj = 0;
34662 wxWindow *arg1 = (wxWindow *) 0 ;
34663 bool result;
34664 void *argp1 = 0 ;
34665 int res1 = 0 ;
34666 PyObject *swig_obj[1] ;
34667
34668 if (!args) SWIG_fail;
34669 swig_obj[0] = args;
34670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34671 if (!SWIG_IsOK(res1)) {
34672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34673 }
34674 arg1 = reinterpret_cast< wxWindow * >(argp1);
34675 {
34676 PyThreadState* __tstate = wxPyBeginAllowThreads();
34677 result = (bool)(arg1)->Validate();
34678 wxPyEndAllowThreads(__tstate);
34679 if (PyErr_Occurred()) SWIG_fail;
34680 }
34681 {
34682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34683 }
34684 return resultobj;
34685 fail:
34686 return NULL;
34687 }
34688
34689
34690 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34691 PyObject *resultobj = 0;
34692 wxWindow *arg1 = (wxWindow *) 0 ;
34693 bool result;
34694 void *argp1 = 0 ;
34695 int res1 = 0 ;
34696 PyObject *swig_obj[1] ;
34697
34698 if (!args) SWIG_fail;
34699 swig_obj[0] = args;
34700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34701 if (!SWIG_IsOK(res1)) {
34702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34703 }
34704 arg1 = reinterpret_cast< wxWindow * >(argp1);
34705 {
34706 PyThreadState* __tstate = wxPyBeginAllowThreads();
34707 result = (bool)(arg1)->TransferDataToWindow();
34708 wxPyEndAllowThreads(__tstate);
34709 if (PyErr_Occurred()) SWIG_fail;
34710 }
34711 {
34712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34713 }
34714 return resultobj;
34715 fail:
34716 return NULL;
34717 }
34718
34719
34720 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34721 PyObject *resultobj = 0;
34722 wxWindow *arg1 = (wxWindow *) 0 ;
34723 bool result;
34724 void *argp1 = 0 ;
34725 int res1 = 0 ;
34726 PyObject *swig_obj[1] ;
34727
34728 if (!args) SWIG_fail;
34729 swig_obj[0] = args;
34730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34731 if (!SWIG_IsOK(res1)) {
34732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34733 }
34734 arg1 = reinterpret_cast< wxWindow * >(argp1);
34735 {
34736 PyThreadState* __tstate = wxPyBeginAllowThreads();
34737 result = (bool)(arg1)->TransferDataFromWindow();
34738 wxPyEndAllowThreads(__tstate);
34739 if (PyErr_Occurred()) SWIG_fail;
34740 }
34741 {
34742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34743 }
34744 return resultobj;
34745 fail:
34746 return NULL;
34747 }
34748
34749
34750 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34751 PyObject *resultobj = 0;
34752 wxWindow *arg1 = (wxWindow *) 0 ;
34753 void *argp1 = 0 ;
34754 int res1 = 0 ;
34755 PyObject *swig_obj[1] ;
34756
34757 if (!args) SWIG_fail;
34758 swig_obj[0] = args;
34759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34760 if (!SWIG_IsOK(res1)) {
34761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34762 }
34763 arg1 = reinterpret_cast< wxWindow * >(argp1);
34764 {
34765 PyThreadState* __tstate = wxPyBeginAllowThreads();
34766 (arg1)->InitDialog();
34767 wxPyEndAllowThreads(__tstate);
34768 if (PyErr_Occurred()) SWIG_fail;
34769 }
34770 resultobj = SWIG_Py_Void();
34771 return resultobj;
34772 fail:
34773 return NULL;
34774 }
34775
34776
34777 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34778 PyObject *resultobj = 0;
34779 wxWindow *arg1 = (wxWindow *) 0 ;
34780 wxAcceleratorTable *arg2 = 0 ;
34781 void *argp1 = 0 ;
34782 int res1 = 0 ;
34783 void *argp2 = 0 ;
34784 int res2 = 0 ;
34785 PyObject * obj0 = 0 ;
34786 PyObject * obj1 = 0 ;
34787 char * kwnames[] = {
34788 (char *) "self",(char *) "accel", NULL
34789 };
34790
34791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34793 if (!SWIG_IsOK(res1)) {
34794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34795 }
34796 arg1 = reinterpret_cast< wxWindow * >(argp1);
34797 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34798 if (!SWIG_IsOK(res2)) {
34799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34800 }
34801 if (!argp2) {
34802 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34803 }
34804 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34805 {
34806 PyThreadState* __tstate = wxPyBeginAllowThreads();
34807 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34808 wxPyEndAllowThreads(__tstate);
34809 if (PyErr_Occurred()) SWIG_fail;
34810 }
34811 resultobj = SWIG_Py_Void();
34812 return resultobj;
34813 fail:
34814 return NULL;
34815 }
34816
34817
34818 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34819 PyObject *resultobj = 0;
34820 wxWindow *arg1 = (wxWindow *) 0 ;
34821 wxAcceleratorTable *result = 0 ;
34822 void *argp1 = 0 ;
34823 int res1 = 0 ;
34824 PyObject *swig_obj[1] ;
34825
34826 if (!args) SWIG_fail;
34827 swig_obj[0] = args;
34828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34829 if (!SWIG_IsOK(res1)) {
34830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34831 }
34832 arg1 = reinterpret_cast< wxWindow * >(argp1);
34833 {
34834 PyThreadState* __tstate = wxPyBeginAllowThreads();
34835 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34836 wxPyEndAllowThreads(__tstate);
34837 if (PyErr_Occurred()) SWIG_fail;
34838 }
34839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34840 return resultobj;
34841 fail:
34842 return NULL;
34843 }
34844
34845
34846 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34847 PyObject *resultobj = 0;
34848 wxWindow *arg1 = (wxWindow *) 0 ;
34849 int arg2 ;
34850 int arg3 ;
34851 int arg4 ;
34852 bool result;
34853 void *argp1 = 0 ;
34854 int res1 = 0 ;
34855 int val2 ;
34856 int ecode2 = 0 ;
34857 int val3 ;
34858 int ecode3 = 0 ;
34859 int val4 ;
34860 int ecode4 = 0 ;
34861 PyObject * obj0 = 0 ;
34862 PyObject * obj1 = 0 ;
34863 PyObject * obj2 = 0 ;
34864 PyObject * obj3 = 0 ;
34865 char * kwnames[] = {
34866 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34867 };
34868
34869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34871 if (!SWIG_IsOK(res1)) {
34872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34873 }
34874 arg1 = reinterpret_cast< wxWindow * >(argp1);
34875 ecode2 = SWIG_AsVal_int(obj1, &val2);
34876 if (!SWIG_IsOK(ecode2)) {
34877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34878 }
34879 arg2 = static_cast< int >(val2);
34880 ecode3 = SWIG_AsVal_int(obj2, &val3);
34881 if (!SWIG_IsOK(ecode3)) {
34882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34883 }
34884 arg3 = static_cast< int >(val3);
34885 ecode4 = SWIG_AsVal_int(obj3, &val4);
34886 if (!SWIG_IsOK(ecode4)) {
34887 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34888 }
34889 arg4 = static_cast< int >(val4);
34890 {
34891 PyThreadState* __tstate = wxPyBeginAllowThreads();
34892 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34893 wxPyEndAllowThreads(__tstate);
34894 if (PyErr_Occurred()) SWIG_fail;
34895 }
34896 {
34897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34898 }
34899 return resultobj;
34900 fail:
34901 return NULL;
34902 }
34903
34904
34905 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34906 PyObject *resultobj = 0;
34907 wxWindow *arg1 = (wxWindow *) 0 ;
34908 int arg2 ;
34909 bool result;
34910 void *argp1 = 0 ;
34911 int res1 = 0 ;
34912 int val2 ;
34913 int ecode2 = 0 ;
34914 PyObject * obj0 = 0 ;
34915 PyObject * obj1 = 0 ;
34916 char * kwnames[] = {
34917 (char *) "self",(char *) "hotkeyId", NULL
34918 };
34919
34920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34922 if (!SWIG_IsOK(res1)) {
34923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34924 }
34925 arg1 = reinterpret_cast< wxWindow * >(argp1);
34926 ecode2 = SWIG_AsVal_int(obj1, &val2);
34927 if (!SWIG_IsOK(ecode2)) {
34928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34929 }
34930 arg2 = static_cast< int >(val2);
34931 {
34932 PyThreadState* __tstate = wxPyBeginAllowThreads();
34933 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34934 wxPyEndAllowThreads(__tstate);
34935 if (PyErr_Occurred()) SWIG_fail;
34936 }
34937 {
34938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34939 }
34940 return resultobj;
34941 fail:
34942 return NULL;
34943 }
34944
34945
34946 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34947 PyObject *resultobj = 0;
34948 wxWindow *arg1 = (wxWindow *) 0 ;
34949 wxPoint *arg2 = 0 ;
34950 wxPoint result;
34951 void *argp1 = 0 ;
34952 int res1 = 0 ;
34953 wxPoint temp2 ;
34954 PyObject * obj0 = 0 ;
34955 PyObject * obj1 = 0 ;
34956 char * kwnames[] = {
34957 (char *) "self",(char *) "pt", NULL
34958 };
34959
34960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34962 if (!SWIG_IsOK(res1)) {
34963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34964 }
34965 arg1 = reinterpret_cast< wxWindow * >(argp1);
34966 {
34967 arg2 = &temp2;
34968 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34969 }
34970 {
34971 PyThreadState* __tstate = wxPyBeginAllowThreads();
34972 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34973 wxPyEndAllowThreads(__tstate);
34974 if (PyErr_Occurred()) SWIG_fail;
34975 }
34976 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34977 return resultobj;
34978 fail:
34979 return NULL;
34980 }
34981
34982
34983 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34984 PyObject *resultobj = 0;
34985 wxWindow *arg1 = (wxWindow *) 0 ;
34986 wxSize *arg2 = 0 ;
34987 wxSize result;
34988 void *argp1 = 0 ;
34989 int res1 = 0 ;
34990 wxSize temp2 ;
34991 PyObject * obj0 = 0 ;
34992 PyObject * obj1 = 0 ;
34993 char * kwnames[] = {
34994 (char *) "self",(char *) "sz", NULL
34995 };
34996
34997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34999 if (!SWIG_IsOK(res1)) {
35000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35001 }
35002 arg1 = reinterpret_cast< wxWindow * >(argp1);
35003 {
35004 arg2 = &temp2;
35005 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35006 }
35007 {
35008 PyThreadState* __tstate = wxPyBeginAllowThreads();
35009 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35010 wxPyEndAllowThreads(__tstate);
35011 if (PyErr_Occurred()) SWIG_fail;
35012 }
35013 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35014 return resultobj;
35015 fail:
35016 return NULL;
35017 }
35018
35019
35020 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35021 PyObject *resultobj = 0;
35022 wxWindow *arg1 = (wxWindow *) 0 ;
35023 wxPoint *arg2 = 0 ;
35024 wxPoint result;
35025 void *argp1 = 0 ;
35026 int res1 = 0 ;
35027 wxPoint temp2 ;
35028 PyObject * obj0 = 0 ;
35029 PyObject * obj1 = 0 ;
35030 char * kwnames[] = {
35031 (char *) "self",(char *) "pt", NULL
35032 };
35033
35034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
35035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35036 if (!SWIG_IsOK(res1)) {
35037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
35038 }
35039 arg1 = reinterpret_cast< wxWindow * >(argp1);
35040 {
35041 arg2 = &temp2;
35042 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35043 }
35044 {
35045 PyThreadState* __tstate = wxPyBeginAllowThreads();
35046 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35047 wxPyEndAllowThreads(__tstate);
35048 if (PyErr_Occurred()) SWIG_fail;
35049 }
35050 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35051 return resultobj;
35052 fail:
35053 return NULL;
35054 }
35055
35056
35057 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35058 PyObject *resultobj = 0;
35059 wxWindow *arg1 = (wxWindow *) 0 ;
35060 wxSize *arg2 = 0 ;
35061 wxSize result;
35062 void *argp1 = 0 ;
35063 int res1 = 0 ;
35064 wxSize temp2 ;
35065 PyObject * obj0 = 0 ;
35066 PyObject * obj1 = 0 ;
35067 char * kwnames[] = {
35068 (char *) "self",(char *) "sz", NULL
35069 };
35070
35071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
35072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35073 if (!SWIG_IsOK(res1)) {
35074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
35075 }
35076 arg1 = reinterpret_cast< wxWindow * >(argp1);
35077 {
35078 arg2 = &temp2;
35079 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35080 }
35081 {
35082 PyThreadState* __tstate = wxPyBeginAllowThreads();
35083 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35084 wxPyEndAllowThreads(__tstate);
35085 if (PyErr_Occurred()) SWIG_fail;
35086 }
35087 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35088 return resultobj;
35089 fail:
35090 return NULL;
35091 }
35092
35093
35094 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35095 PyObject *resultobj = 0;
35096 wxWindow *arg1 = (wxWindow *) 0 ;
35097 wxPoint *arg2 = 0 ;
35098 wxPoint result;
35099 void *argp1 = 0 ;
35100 int res1 = 0 ;
35101 wxPoint temp2 ;
35102 PyObject * obj0 = 0 ;
35103 PyObject * obj1 = 0 ;
35104 char * kwnames[] = {
35105 (char *) "self",(char *) "pt", NULL
35106 };
35107
35108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35110 if (!SWIG_IsOK(res1)) {
35111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35112 }
35113 arg1 = reinterpret_cast< wxWindow * >(argp1);
35114 {
35115 arg2 = &temp2;
35116 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35117 }
35118 {
35119 PyThreadState* __tstate = wxPyBeginAllowThreads();
35120 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
35121 wxPyEndAllowThreads(__tstate);
35122 if (PyErr_Occurred()) SWIG_fail;
35123 }
35124 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35125 return resultobj;
35126 fail:
35127 return NULL;
35128 }
35129
35130
35131 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35132 PyObject *resultobj = 0;
35133 wxWindow *arg1 = (wxWindow *) 0 ;
35134 wxSize *arg2 = 0 ;
35135 wxSize result;
35136 void *argp1 = 0 ;
35137 int res1 = 0 ;
35138 wxSize temp2 ;
35139 PyObject * obj0 = 0 ;
35140 PyObject * obj1 = 0 ;
35141 char * kwnames[] = {
35142 (char *) "self",(char *) "sz", NULL
35143 };
35144
35145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35147 if (!SWIG_IsOK(res1)) {
35148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35149 }
35150 arg1 = reinterpret_cast< wxWindow * >(argp1);
35151 {
35152 arg2 = &temp2;
35153 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35154 }
35155 {
35156 PyThreadState* __tstate = wxPyBeginAllowThreads();
35157 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
35158 wxPyEndAllowThreads(__tstate);
35159 if (PyErr_Occurred()) SWIG_fail;
35160 }
35161 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35162 return resultobj;
35163 fail:
35164 return NULL;
35165 }
35166
35167
35168 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35169 PyObject *resultobj = 0;
35170 wxWindow *arg1 = (wxWindow *) 0 ;
35171 int arg2 ;
35172 int arg3 ;
35173 void *argp1 = 0 ;
35174 int res1 = 0 ;
35175 int val2 ;
35176 int ecode2 = 0 ;
35177 int val3 ;
35178 int ecode3 = 0 ;
35179 PyObject * obj0 = 0 ;
35180 PyObject * obj1 = 0 ;
35181 PyObject * obj2 = 0 ;
35182 char * kwnames[] = {
35183 (char *) "self",(char *) "x",(char *) "y", NULL
35184 };
35185
35186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35188 if (!SWIG_IsOK(res1)) {
35189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
35190 }
35191 arg1 = reinterpret_cast< wxWindow * >(argp1);
35192 ecode2 = SWIG_AsVal_int(obj1, &val2);
35193 if (!SWIG_IsOK(ecode2)) {
35194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
35195 }
35196 arg2 = static_cast< int >(val2);
35197 ecode3 = SWIG_AsVal_int(obj2, &val3);
35198 if (!SWIG_IsOK(ecode3)) {
35199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
35200 }
35201 arg3 = static_cast< int >(val3);
35202 {
35203 PyThreadState* __tstate = wxPyBeginAllowThreads();
35204 (arg1)->WarpPointer(arg2,arg3);
35205 wxPyEndAllowThreads(__tstate);
35206 if (PyErr_Occurred()) SWIG_fail;
35207 }
35208 resultobj = SWIG_Py_Void();
35209 return resultobj;
35210 fail:
35211 return NULL;
35212 }
35213
35214
35215 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35216 PyObject *resultobj = 0;
35217 wxWindow *arg1 = (wxWindow *) 0 ;
35218 void *argp1 = 0 ;
35219 int res1 = 0 ;
35220 PyObject *swig_obj[1] ;
35221
35222 if (!args) SWIG_fail;
35223 swig_obj[0] = args;
35224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35225 if (!SWIG_IsOK(res1)) {
35226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35227 }
35228 arg1 = reinterpret_cast< wxWindow * >(argp1);
35229 {
35230 PyThreadState* __tstate = wxPyBeginAllowThreads();
35231 (arg1)->CaptureMouse();
35232 wxPyEndAllowThreads(__tstate);
35233 if (PyErr_Occurred()) SWIG_fail;
35234 }
35235 resultobj = SWIG_Py_Void();
35236 return resultobj;
35237 fail:
35238 return NULL;
35239 }
35240
35241
35242 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35243 PyObject *resultobj = 0;
35244 wxWindow *arg1 = (wxWindow *) 0 ;
35245 void *argp1 = 0 ;
35246 int res1 = 0 ;
35247 PyObject *swig_obj[1] ;
35248
35249 if (!args) SWIG_fail;
35250 swig_obj[0] = args;
35251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35252 if (!SWIG_IsOK(res1)) {
35253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35254 }
35255 arg1 = reinterpret_cast< wxWindow * >(argp1);
35256 {
35257 PyThreadState* __tstate = wxPyBeginAllowThreads();
35258 (arg1)->ReleaseMouse();
35259 wxPyEndAllowThreads(__tstate);
35260 if (PyErr_Occurred()) SWIG_fail;
35261 }
35262 resultobj = SWIG_Py_Void();
35263 return resultobj;
35264 fail:
35265 return NULL;
35266 }
35267
35268
35269 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35270 PyObject *resultobj = 0;
35271 wxWindow *result = 0 ;
35272
35273 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
35274 {
35275 if (!wxPyCheckForApp()) SWIG_fail;
35276 PyThreadState* __tstate = wxPyBeginAllowThreads();
35277 result = (wxWindow *)wxWindow::GetCapture();
35278 wxPyEndAllowThreads(__tstate);
35279 if (PyErr_Occurred()) SWIG_fail;
35280 }
35281 {
35282 resultobj = wxPyMake_wxObject(result, 0);
35283 }
35284 return resultobj;
35285 fail:
35286 return NULL;
35287 }
35288
35289
35290 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35291 PyObject *resultobj = 0;
35292 wxWindow *arg1 = (wxWindow *) 0 ;
35293 bool result;
35294 void *argp1 = 0 ;
35295 int res1 = 0 ;
35296 PyObject *swig_obj[1] ;
35297
35298 if (!args) SWIG_fail;
35299 swig_obj[0] = args;
35300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35301 if (!SWIG_IsOK(res1)) {
35302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
35303 }
35304 arg1 = reinterpret_cast< wxWindow * >(argp1);
35305 {
35306 PyThreadState* __tstate = wxPyBeginAllowThreads();
35307 result = (bool)((wxWindow const *)arg1)->HasCapture();
35308 wxPyEndAllowThreads(__tstate);
35309 if (PyErr_Occurred()) SWIG_fail;
35310 }
35311 {
35312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35313 }
35314 return resultobj;
35315 fail:
35316 return NULL;
35317 }
35318
35319
35320 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35321 PyObject *resultobj = 0;
35322 wxWindow *arg1 = (wxWindow *) 0 ;
35323 bool arg2 = (bool) true ;
35324 wxRect *arg3 = (wxRect *) NULL ;
35325 void *argp1 = 0 ;
35326 int res1 = 0 ;
35327 bool val2 ;
35328 int ecode2 = 0 ;
35329 void *argp3 = 0 ;
35330 int res3 = 0 ;
35331 PyObject * obj0 = 0 ;
35332 PyObject * obj1 = 0 ;
35333 PyObject * obj2 = 0 ;
35334 char * kwnames[] = {
35335 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
35336 };
35337
35338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35340 if (!SWIG_IsOK(res1)) {
35341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
35342 }
35343 arg1 = reinterpret_cast< wxWindow * >(argp1);
35344 if (obj1) {
35345 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35346 if (!SWIG_IsOK(ecode2)) {
35347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
35348 }
35349 arg2 = static_cast< bool >(val2);
35350 }
35351 if (obj2) {
35352 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
35353 if (!SWIG_IsOK(res3)) {
35354 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
35355 }
35356 arg3 = reinterpret_cast< wxRect * >(argp3);
35357 }
35358 {
35359 PyThreadState* __tstate = wxPyBeginAllowThreads();
35360 (arg1)->Refresh(arg2,(wxRect const *)arg3);
35361 wxPyEndAllowThreads(__tstate);
35362 if (PyErr_Occurred()) SWIG_fail;
35363 }
35364 resultobj = SWIG_Py_Void();
35365 return resultobj;
35366 fail:
35367 return NULL;
35368 }
35369
35370
35371 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35372 PyObject *resultobj = 0;
35373 wxWindow *arg1 = (wxWindow *) 0 ;
35374 wxRect *arg2 = 0 ;
35375 bool arg3 = (bool) true ;
35376 void *argp1 = 0 ;
35377 int res1 = 0 ;
35378 wxRect temp2 ;
35379 bool val3 ;
35380 int ecode3 = 0 ;
35381 PyObject * obj0 = 0 ;
35382 PyObject * obj1 = 0 ;
35383 PyObject * obj2 = 0 ;
35384 char * kwnames[] = {
35385 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
35386 };
35387
35388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35390 if (!SWIG_IsOK(res1)) {
35391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
35392 }
35393 arg1 = reinterpret_cast< wxWindow * >(argp1);
35394 {
35395 arg2 = &temp2;
35396 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35397 }
35398 if (obj2) {
35399 ecode3 = SWIG_AsVal_bool(obj2, &val3);
35400 if (!SWIG_IsOK(ecode3)) {
35401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
35402 }
35403 arg3 = static_cast< bool >(val3);
35404 }
35405 {
35406 PyThreadState* __tstate = wxPyBeginAllowThreads();
35407 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
35408 wxPyEndAllowThreads(__tstate);
35409 if (PyErr_Occurred()) SWIG_fail;
35410 }
35411 resultobj = SWIG_Py_Void();
35412 return resultobj;
35413 fail:
35414 return NULL;
35415 }
35416
35417
35418 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35419 PyObject *resultobj = 0;
35420 wxWindow *arg1 = (wxWindow *) 0 ;
35421 void *argp1 = 0 ;
35422 int res1 = 0 ;
35423 PyObject *swig_obj[1] ;
35424
35425 if (!args) SWIG_fail;
35426 swig_obj[0] = args;
35427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35428 if (!SWIG_IsOK(res1)) {
35429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
35430 }
35431 arg1 = reinterpret_cast< wxWindow * >(argp1);
35432 {
35433 PyThreadState* __tstate = wxPyBeginAllowThreads();
35434 (arg1)->Update();
35435 wxPyEndAllowThreads(__tstate);
35436 if (PyErr_Occurred()) SWIG_fail;
35437 }
35438 resultobj = SWIG_Py_Void();
35439 return resultobj;
35440 fail:
35441 return NULL;
35442 }
35443
35444
35445 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35446 PyObject *resultobj = 0;
35447 wxWindow *arg1 = (wxWindow *) 0 ;
35448 void *argp1 = 0 ;
35449 int res1 = 0 ;
35450 PyObject *swig_obj[1] ;
35451
35452 if (!args) SWIG_fail;
35453 swig_obj[0] = args;
35454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35455 if (!SWIG_IsOK(res1)) {
35456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35457 }
35458 arg1 = reinterpret_cast< wxWindow * >(argp1);
35459 {
35460 PyThreadState* __tstate = wxPyBeginAllowThreads();
35461 (arg1)->ClearBackground();
35462 wxPyEndAllowThreads(__tstate);
35463 if (PyErr_Occurred()) SWIG_fail;
35464 }
35465 resultobj = SWIG_Py_Void();
35466 return resultobj;
35467 fail:
35468 return NULL;
35469 }
35470
35471
35472 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35473 PyObject *resultobj = 0;
35474 wxWindow *arg1 = (wxWindow *) 0 ;
35475 void *argp1 = 0 ;
35476 int res1 = 0 ;
35477 PyObject *swig_obj[1] ;
35478
35479 if (!args) SWIG_fail;
35480 swig_obj[0] = args;
35481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35482 if (!SWIG_IsOK(res1)) {
35483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35484 }
35485 arg1 = reinterpret_cast< wxWindow * >(argp1);
35486 {
35487 PyThreadState* __tstate = wxPyBeginAllowThreads();
35488 (arg1)->Freeze();
35489 wxPyEndAllowThreads(__tstate);
35490 if (PyErr_Occurred()) SWIG_fail;
35491 }
35492 resultobj = SWIG_Py_Void();
35493 return resultobj;
35494 fail:
35495 return NULL;
35496 }
35497
35498
35499 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35500 PyObject *resultobj = 0;
35501 wxWindow *arg1 = (wxWindow *) 0 ;
35502 bool result;
35503 void *argp1 = 0 ;
35504 int res1 = 0 ;
35505 PyObject *swig_obj[1] ;
35506
35507 if (!args) SWIG_fail;
35508 swig_obj[0] = args;
35509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35510 if (!SWIG_IsOK(res1)) {
35511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35512 }
35513 arg1 = reinterpret_cast< wxWindow * >(argp1);
35514 {
35515 PyThreadState* __tstate = wxPyBeginAllowThreads();
35516 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35517 wxPyEndAllowThreads(__tstate);
35518 if (PyErr_Occurred()) SWIG_fail;
35519 }
35520 {
35521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35522 }
35523 return resultobj;
35524 fail:
35525 return NULL;
35526 }
35527
35528
35529 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35530 PyObject *resultobj = 0;
35531 wxWindow *arg1 = (wxWindow *) 0 ;
35532 void *argp1 = 0 ;
35533 int res1 = 0 ;
35534 PyObject *swig_obj[1] ;
35535
35536 if (!args) SWIG_fail;
35537 swig_obj[0] = args;
35538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35539 if (!SWIG_IsOK(res1)) {
35540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35541 }
35542 arg1 = reinterpret_cast< wxWindow * >(argp1);
35543 {
35544 PyThreadState* __tstate = wxPyBeginAllowThreads();
35545 (arg1)->Thaw();
35546 wxPyEndAllowThreads(__tstate);
35547 if (PyErr_Occurred()) SWIG_fail;
35548 }
35549 resultobj = SWIG_Py_Void();
35550 return resultobj;
35551 fail:
35552 return NULL;
35553 }
35554
35555
35556 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35557 PyObject *resultobj = 0;
35558 wxWindow *arg1 = (wxWindow *) 0 ;
35559 wxDC *arg2 = 0 ;
35560 void *argp1 = 0 ;
35561 int res1 = 0 ;
35562 void *argp2 = 0 ;
35563 int res2 = 0 ;
35564 PyObject * obj0 = 0 ;
35565 PyObject * obj1 = 0 ;
35566 char * kwnames[] = {
35567 (char *) "self",(char *) "dc", NULL
35568 };
35569
35570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35572 if (!SWIG_IsOK(res1)) {
35573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35574 }
35575 arg1 = reinterpret_cast< wxWindow * >(argp1);
35576 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35577 if (!SWIG_IsOK(res2)) {
35578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35579 }
35580 if (!argp2) {
35581 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35582 }
35583 arg2 = reinterpret_cast< wxDC * >(argp2);
35584 {
35585 PyThreadState* __tstate = wxPyBeginAllowThreads();
35586 (arg1)->PrepareDC(*arg2);
35587 wxPyEndAllowThreads(__tstate);
35588 if (PyErr_Occurred()) SWIG_fail;
35589 }
35590 resultobj = SWIG_Py_Void();
35591 return resultobj;
35592 fail:
35593 return NULL;
35594 }
35595
35596
35597 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35598 PyObject *resultobj = 0;
35599 wxWindow *arg1 = (wxWindow *) 0 ;
35600 wxRegion *result = 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_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35610 }
35611 arg1 = reinterpret_cast< wxWindow * >(argp1);
35612 {
35613 PyThreadState* __tstate = wxPyBeginAllowThreads();
35614 {
35615 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35616 result = (wxRegion *) &_result_ref;
35617 }
35618 wxPyEndAllowThreads(__tstate);
35619 if (PyErr_Occurred()) SWIG_fail;
35620 }
35621 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35622 return resultobj;
35623 fail:
35624 return NULL;
35625 }
35626
35627
35628 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35629 PyObject *resultobj = 0;
35630 wxWindow *arg1 = (wxWindow *) 0 ;
35631 wxRect result;
35632 void *argp1 = 0 ;
35633 int res1 = 0 ;
35634 PyObject *swig_obj[1] ;
35635
35636 if (!args) SWIG_fail;
35637 swig_obj[0] = args;
35638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35639 if (!SWIG_IsOK(res1)) {
35640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35641 }
35642 arg1 = reinterpret_cast< wxWindow * >(argp1);
35643 {
35644 PyThreadState* __tstate = wxPyBeginAllowThreads();
35645 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35646 wxPyEndAllowThreads(__tstate);
35647 if (PyErr_Occurred()) SWIG_fail;
35648 }
35649 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35650 return resultobj;
35651 fail:
35652 return NULL;
35653 }
35654
35655
35656 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35657 PyObject *resultobj = 0;
35658 wxWindow *arg1 = (wxWindow *) 0 ;
35659 int arg2 ;
35660 int arg3 ;
35661 int arg4 = (int) 1 ;
35662 int arg5 = (int) 1 ;
35663 bool result;
35664 void *argp1 = 0 ;
35665 int res1 = 0 ;
35666 int val2 ;
35667 int ecode2 = 0 ;
35668 int val3 ;
35669 int ecode3 = 0 ;
35670 int val4 ;
35671 int ecode4 = 0 ;
35672 int val5 ;
35673 int ecode5 = 0 ;
35674 PyObject * obj0 = 0 ;
35675 PyObject * obj1 = 0 ;
35676 PyObject * obj2 = 0 ;
35677 PyObject * obj3 = 0 ;
35678 PyObject * obj4 = 0 ;
35679 char * kwnames[] = {
35680 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35681 };
35682
35683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35685 if (!SWIG_IsOK(res1)) {
35686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35687 }
35688 arg1 = reinterpret_cast< wxWindow * >(argp1);
35689 ecode2 = SWIG_AsVal_int(obj1, &val2);
35690 if (!SWIG_IsOK(ecode2)) {
35691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35692 }
35693 arg2 = static_cast< int >(val2);
35694 ecode3 = SWIG_AsVal_int(obj2, &val3);
35695 if (!SWIG_IsOK(ecode3)) {
35696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35697 }
35698 arg3 = static_cast< int >(val3);
35699 if (obj3) {
35700 ecode4 = SWIG_AsVal_int(obj3, &val4);
35701 if (!SWIG_IsOK(ecode4)) {
35702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35703 }
35704 arg4 = static_cast< int >(val4);
35705 }
35706 if (obj4) {
35707 ecode5 = SWIG_AsVal_int(obj4, &val5);
35708 if (!SWIG_IsOK(ecode5)) {
35709 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35710 }
35711 arg5 = static_cast< int >(val5);
35712 }
35713 {
35714 PyThreadState* __tstate = wxPyBeginAllowThreads();
35715 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35716 wxPyEndAllowThreads(__tstate);
35717 if (PyErr_Occurred()) SWIG_fail;
35718 }
35719 {
35720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35721 }
35722 return resultobj;
35723 fail:
35724 return NULL;
35725 }
35726
35727
35728 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35729 PyObject *resultobj = 0;
35730 wxWindow *arg1 = (wxWindow *) 0 ;
35731 wxPoint *arg2 = 0 ;
35732 bool result;
35733 void *argp1 = 0 ;
35734 int res1 = 0 ;
35735 wxPoint temp2 ;
35736 PyObject * obj0 = 0 ;
35737 PyObject * obj1 = 0 ;
35738 char * kwnames[] = {
35739 (char *) "self",(char *) "pt", NULL
35740 };
35741
35742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35744 if (!SWIG_IsOK(res1)) {
35745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35746 }
35747 arg1 = reinterpret_cast< wxWindow * >(argp1);
35748 {
35749 arg2 = &temp2;
35750 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35751 }
35752 {
35753 PyThreadState* __tstate = wxPyBeginAllowThreads();
35754 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35755 wxPyEndAllowThreads(__tstate);
35756 if (PyErr_Occurred()) SWIG_fail;
35757 }
35758 {
35759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35760 }
35761 return resultobj;
35762 fail:
35763 return NULL;
35764 }
35765
35766
35767 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35768 PyObject *resultobj = 0;
35769 wxWindow *arg1 = (wxWindow *) 0 ;
35770 wxRect *arg2 = 0 ;
35771 bool result;
35772 void *argp1 = 0 ;
35773 int res1 = 0 ;
35774 wxRect temp2 ;
35775 PyObject * obj0 = 0 ;
35776 PyObject * obj1 = 0 ;
35777 char * kwnames[] = {
35778 (char *) "self",(char *) "rect", NULL
35779 };
35780
35781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35783 if (!SWIG_IsOK(res1)) {
35784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35785 }
35786 arg1 = reinterpret_cast< wxWindow * >(argp1);
35787 {
35788 arg2 = &temp2;
35789 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35790 }
35791 {
35792 PyThreadState* __tstate = wxPyBeginAllowThreads();
35793 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35794 wxPyEndAllowThreads(__tstate);
35795 if (PyErr_Occurred()) SWIG_fail;
35796 }
35797 {
35798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35799 }
35800 return resultobj;
35801 fail:
35802 return NULL;
35803 }
35804
35805
35806 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35807 PyObject *resultobj = 0;
35808 wxWindow *arg1 = (wxWindow *) 0 ;
35809 SwigValueWrapper<wxVisualAttributes > result;
35810 void *argp1 = 0 ;
35811 int res1 = 0 ;
35812 PyObject *swig_obj[1] ;
35813
35814 if (!args) SWIG_fail;
35815 swig_obj[0] = args;
35816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35817 if (!SWIG_IsOK(res1)) {
35818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35819 }
35820 arg1 = reinterpret_cast< wxWindow * >(argp1);
35821 {
35822 PyThreadState* __tstate = wxPyBeginAllowThreads();
35823 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35824 wxPyEndAllowThreads(__tstate);
35825 if (PyErr_Occurred()) SWIG_fail;
35826 }
35827 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35828 return resultobj;
35829 fail:
35830 return NULL;
35831 }
35832
35833
35834 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35835 PyObject *resultobj = 0;
35836 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35837 SwigValueWrapper<wxVisualAttributes > result;
35838 int val1 ;
35839 int ecode1 = 0 ;
35840 PyObject * obj0 = 0 ;
35841 char * kwnames[] = {
35842 (char *) "variant", NULL
35843 };
35844
35845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
35846 if (obj0) {
35847 ecode1 = SWIG_AsVal_int(obj0, &val1);
35848 if (!SWIG_IsOK(ecode1)) {
35849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
35850 }
35851 arg1 = static_cast< wxWindowVariant >(val1);
35852 }
35853 {
35854 if (!wxPyCheckForApp()) SWIG_fail;
35855 PyThreadState* __tstate = wxPyBeginAllowThreads();
35856 result = wxWindow::GetClassDefaultAttributes(arg1);
35857 wxPyEndAllowThreads(__tstate);
35858 if (PyErr_Occurred()) SWIG_fail;
35859 }
35860 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35861 return resultobj;
35862 fail:
35863 return NULL;
35864 }
35865
35866
35867 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35868 PyObject *resultobj = 0;
35869 wxWindow *arg1 = (wxWindow *) 0 ;
35870 wxColour *arg2 = 0 ;
35871 bool result;
35872 void *argp1 = 0 ;
35873 int res1 = 0 ;
35874 wxColour temp2 ;
35875 PyObject * obj0 = 0 ;
35876 PyObject * obj1 = 0 ;
35877 char * kwnames[] = {
35878 (char *) "self",(char *) "colour", NULL
35879 };
35880
35881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35883 if (!SWIG_IsOK(res1)) {
35884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35885 }
35886 arg1 = reinterpret_cast< wxWindow * >(argp1);
35887 {
35888 arg2 = &temp2;
35889 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35890 }
35891 {
35892 PyThreadState* __tstate = wxPyBeginAllowThreads();
35893 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35894 wxPyEndAllowThreads(__tstate);
35895 if (PyErr_Occurred()) SWIG_fail;
35896 }
35897 {
35898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35899 }
35900 return resultobj;
35901 fail:
35902 return NULL;
35903 }
35904
35905
35906 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35907 PyObject *resultobj = 0;
35908 wxWindow *arg1 = (wxWindow *) 0 ;
35909 wxColour *arg2 = 0 ;
35910 void *argp1 = 0 ;
35911 int res1 = 0 ;
35912 wxColour temp2 ;
35913 PyObject * obj0 = 0 ;
35914 PyObject * obj1 = 0 ;
35915 char * kwnames[] = {
35916 (char *) "self",(char *) "colour", NULL
35917 };
35918
35919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35921 if (!SWIG_IsOK(res1)) {
35922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35923 }
35924 arg1 = reinterpret_cast< wxWindow * >(argp1);
35925 {
35926 arg2 = &temp2;
35927 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35928 }
35929 {
35930 PyThreadState* __tstate = wxPyBeginAllowThreads();
35931 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35932 wxPyEndAllowThreads(__tstate);
35933 if (PyErr_Occurred()) SWIG_fail;
35934 }
35935 resultobj = SWIG_Py_Void();
35936 return resultobj;
35937 fail:
35938 return NULL;
35939 }
35940
35941
35942 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35943 PyObject *resultobj = 0;
35944 wxWindow *arg1 = (wxWindow *) 0 ;
35945 wxColour *arg2 = 0 ;
35946 bool result;
35947 void *argp1 = 0 ;
35948 int res1 = 0 ;
35949 wxColour temp2 ;
35950 PyObject * obj0 = 0 ;
35951 PyObject * obj1 = 0 ;
35952 char * kwnames[] = {
35953 (char *) "self",(char *) "colour", NULL
35954 };
35955
35956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35958 if (!SWIG_IsOK(res1)) {
35959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35960 }
35961 arg1 = reinterpret_cast< wxWindow * >(argp1);
35962 {
35963 arg2 = &temp2;
35964 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35965 }
35966 {
35967 PyThreadState* __tstate = wxPyBeginAllowThreads();
35968 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35969 wxPyEndAllowThreads(__tstate);
35970 if (PyErr_Occurred()) SWIG_fail;
35971 }
35972 {
35973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35974 }
35975 return resultobj;
35976 fail:
35977 return NULL;
35978 }
35979
35980
35981 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35982 PyObject *resultobj = 0;
35983 wxWindow *arg1 = (wxWindow *) 0 ;
35984 wxColour *arg2 = 0 ;
35985 void *argp1 = 0 ;
35986 int res1 = 0 ;
35987 wxColour temp2 ;
35988 PyObject * obj0 = 0 ;
35989 PyObject * obj1 = 0 ;
35990 char * kwnames[] = {
35991 (char *) "self",(char *) "colour", NULL
35992 };
35993
35994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35996 if (!SWIG_IsOK(res1)) {
35997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35998 }
35999 arg1 = reinterpret_cast< wxWindow * >(argp1);
36000 {
36001 arg2 = &temp2;
36002 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36003 }
36004 {
36005 PyThreadState* __tstate = wxPyBeginAllowThreads();
36006 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
36007 wxPyEndAllowThreads(__tstate);
36008 if (PyErr_Occurred()) SWIG_fail;
36009 }
36010 resultobj = SWIG_Py_Void();
36011 return resultobj;
36012 fail:
36013 return NULL;
36014 }
36015
36016
36017 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36018 PyObject *resultobj = 0;
36019 wxWindow *arg1 = (wxWindow *) 0 ;
36020 wxColour result;
36021 void *argp1 = 0 ;
36022 int res1 = 0 ;
36023 PyObject *swig_obj[1] ;
36024
36025 if (!args) SWIG_fail;
36026 swig_obj[0] = args;
36027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36028 if (!SWIG_IsOK(res1)) {
36029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36030 }
36031 arg1 = reinterpret_cast< wxWindow * >(argp1);
36032 {
36033 PyThreadState* __tstate = wxPyBeginAllowThreads();
36034 result = ((wxWindow const *)arg1)->GetBackgroundColour();
36035 wxPyEndAllowThreads(__tstate);
36036 if (PyErr_Occurred()) SWIG_fail;
36037 }
36038 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36039 return resultobj;
36040 fail:
36041 return NULL;
36042 }
36043
36044
36045 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36046 PyObject *resultobj = 0;
36047 wxWindow *arg1 = (wxWindow *) 0 ;
36048 wxColour result;
36049 void *argp1 = 0 ;
36050 int res1 = 0 ;
36051 PyObject *swig_obj[1] ;
36052
36053 if (!args) SWIG_fail;
36054 swig_obj[0] = args;
36055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36056 if (!SWIG_IsOK(res1)) {
36057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36058 }
36059 arg1 = reinterpret_cast< wxWindow * >(argp1);
36060 {
36061 PyThreadState* __tstate = wxPyBeginAllowThreads();
36062 result = ((wxWindow const *)arg1)->GetForegroundColour();
36063 wxPyEndAllowThreads(__tstate);
36064 if (PyErr_Occurred()) SWIG_fail;
36065 }
36066 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36067 return resultobj;
36068 fail:
36069 return NULL;
36070 }
36071
36072
36073 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36074 PyObject *resultobj = 0;
36075 wxWindow *arg1 = (wxWindow *) 0 ;
36076 bool result;
36077 void *argp1 = 0 ;
36078 int res1 = 0 ;
36079 PyObject *swig_obj[1] ;
36080
36081 if (!args) SWIG_fail;
36082 swig_obj[0] = args;
36083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36084 if (!SWIG_IsOK(res1)) {
36085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36086 }
36087 arg1 = reinterpret_cast< wxWindow * >(argp1);
36088 {
36089 PyThreadState* __tstate = wxPyBeginAllowThreads();
36090 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
36091 wxPyEndAllowThreads(__tstate);
36092 if (PyErr_Occurred()) SWIG_fail;
36093 }
36094 {
36095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36096 }
36097 return resultobj;
36098 fail:
36099 return NULL;
36100 }
36101
36102
36103 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36104 PyObject *resultobj = 0;
36105 wxWindow *arg1 = (wxWindow *) 0 ;
36106 bool result;
36107 void *argp1 = 0 ;
36108 int res1 = 0 ;
36109 PyObject *swig_obj[1] ;
36110
36111 if (!args) SWIG_fail;
36112 swig_obj[0] = args;
36113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36114 if (!SWIG_IsOK(res1)) {
36115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
36116 }
36117 arg1 = reinterpret_cast< wxWindow * >(argp1);
36118 {
36119 PyThreadState* __tstate = wxPyBeginAllowThreads();
36120 result = (bool)((wxWindow const *)arg1)->UseBgCol();
36121 wxPyEndAllowThreads(__tstate);
36122 if (PyErr_Occurred()) SWIG_fail;
36123 }
36124 {
36125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36126 }
36127 return resultobj;
36128 fail:
36129 return NULL;
36130 }
36131
36132
36133 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36134 PyObject *resultobj = 0;
36135 wxWindow *arg1 = (wxWindow *) 0 ;
36136 wxBackgroundStyle arg2 ;
36137 bool result;
36138 void *argp1 = 0 ;
36139 int res1 = 0 ;
36140 int val2 ;
36141 int ecode2 = 0 ;
36142 PyObject * obj0 = 0 ;
36143 PyObject * obj1 = 0 ;
36144 char * kwnames[] = {
36145 (char *) "self",(char *) "style", NULL
36146 };
36147
36148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36150 if (!SWIG_IsOK(res1)) {
36151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36152 }
36153 arg1 = reinterpret_cast< wxWindow * >(argp1);
36154 ecode2 = SWIG_AsVal_int(obj1, &val2);
36155 if (!SWIG_IsOK(ecode2)) {
36156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
36157 }
36158 arg2 = static_cast< wxBackgroundStyle >(val2);
36159 {
36160 PyThreadState* __tstate = wxPyBeginAllowThreads();
36161 result = (bool)(arg1)->SetBackgroundStyle(arg2);
36162 wxPyEndAllowThreads(__tstate);
36163 if (PyErr_Occurred()) SWIG_fail;
36164 }
36165 {
36166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36167 }
36168 return resultobj;
36169 fail:
36170 return NULL;
36171 }
36172
36173
36174 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36175 PyObject *resultobj = 0;
36176 wxWindow *arg1 = (wxWindow *) 0 ;
36177 wxBackgroundStyle result;
36178 void *argp1 = 0 ;
36179 int res1 = 0 ;
36180 PyObject *swig_obj[1] ;
36181
36182 if (!args) SWIG_fail;
36183 swig_obj[0] = args;
36184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36185 if (!SWIG_IsOK(res1)) {
36186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36187 }
36188 arg1 = reinterpret_cast< wxWindow * >(argp1);
36189 {
36190 PyThreadState* __tstate = wxPyBeginAllowThreads();
36191 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
36192 wxPyEndAllowThreads(__tstate);
36193 if (PyErr_Occurred()) SWIG_fail;
36194 }
36195 resultobj = SWIG_From_int(static_cast< int >(result));
36196 return resultobj;
36197 fail:
36198 return NULL;
36199 }
36200
36201
36202 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36203 PyObject *resultobj = 0;
36204 wxWindow *arg1 = (wxWindow *) 0 ;
36205 bool result;
36206 void *argp1 = 0 ;
36207 int res1 = 0 ;
36208 PyObject *swig_obj[1] ;
36209
36210 if (!args) SWIG_fail;
36211 swig_obj[0] = args;
36212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36213 if (!SWIG_IsOK(res1)) {
36214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
36215 }
36216 arg1 = reinterpret_cast< wxWindow * >(argp1);
36217 {
36218 PyThreadState* __tstate = wxPyBeginAllowThreads();
36219 result = (bool)(arg1)->HasTransparentBackground();
36220 wxPyEndAllowThreads(__tstate);
36221 if (PyErr_Occurred()) SWIG_fail;
36222 }
36223 {
36224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36225 }
36226 return resultobj;
36227 fail:
36228 return NULL;
36229 }
36230
36231
36232 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36233 PyObject *resultobj = 0;
36234 wxWindow *arg1 = (wxWindow *) 0 ;
36235 wxCursor *arg2 = 0 ;
36236 bool result;
36237 void *argp1 = 0 ;
36238 int res1 = 0 ;
36239 void *argp2 = 0 ;
36240 int res2 = 0 ;
36241 PyObject * obj0 = 0 ;
36242 PyObject * obj1 = 0 ;
36243 char * kwnames[] = {
36244 (char *) "self",(char *) "cursor", NULL
36245 };
36246
36247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
36248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36249 if (!SWIG_IsOK(res1)) {
36250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36251 }
36252 arg1 = reinterpret_cast< wxWindow * >(argp1);
36253 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
36254 if (!SWIG_IsOK(res2)) {
36255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36256 }
36257 if (!argp2) {
36258 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36259 }
36260 arg2 = reinterpret_cast< wxCursor * >(argp2);
36261 {
36262 PyThreadState* __tstate = wxPyBeginAllowThreads();
36263 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
36264 wxPyEndAllowThreads(__tstate);
36265 if (PyErr_Occurred()) SWIG_fail;
36266 }
36267 {
36268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36269 }
36270 return resultobj;
36271 fail:
36272 return NULL;
36273 }
36274
36275
36276 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36277 PyObject *resultobj = 0;
36278 wxWindow *arg1 = (wxWindow *) 0 ;
36279 wxCursor result;
36280 void *argp1 = 0 ;
36281 int res1 = 0 ;
36282 PyObject *swig_obj[1] ;
36283
36284 if (!args) SWIG_fail;
36285 swig_obj[0] = args;
36286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36287 if (!SWIG_IsOK(res1)) {
36288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36289 }
36290 arg1 = reinterpret_cast< wxWindow * >(argp1);
36291 {
36292 PyThreadState* __tstate = wxPyBeginAllowThreads();
36293 result = (arg1)->GetCursor();
36294 wxPyEndAllowThreads(__tstate);
36295 if (PyErr_Occurred()) SWIG_fail;
36296 }
36297 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
36298 return resultobj;
36299 fail:
36300 return NULL;
36301 }
36302
36303
36304 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36305 PyObject *resultobj = 0;
36306 wxWindow *arg1 = (wxWindow *) 0 ;
36307 wxFont *arg2 = 0 ;
36308 bool result;
36309 void *argp1 = 0 ;
36310 int res1 = 0 ;
36311 void *argp2 = 0 ;
36312 int res2 = 0 ;
36313 PyObject * obj0 = 0 ;
36314 PyObject * obj1 = 0 ;
36315 char * kwnames[] = {
36316 (char *) "self",(char *) "font", NULL
36317 };
36318
36319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
36320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36321 if (!SWIG_IsOK(res1)) {
36322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36323 }
36324 arg1 = reinterpret_cast< wxWindow * >(argp1);
36325 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36326 if (!SWIG_IsOK(res2)) {
36327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36328 }
36329 if (!argp2) {
36330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36331 }
36332 arg2 = reinterpret_cast< wxFont * >(argp2);
36333 {
36334 PyThreadState* __tstate = wxPyBeginAllowThreads();
36335 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
36336 wxPyEndAllowThreads(__tstate);
36337 if (PyErr_Occurred()) SWIG_fail;
36338 }
36339 {
36340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36341 }
36342 return resultobj;
36343 fail:
36344 return NULL;
36345 }
36346
36347
36348 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36349 PyObject *resultobj = 0;
36350 wxWindow *arg1 = (wxWindow *) 0 ;
36351 wxFont *arg2 = 0 ;
36352 void *argp1 = 0 ;
36353 int res1 = 0 ;
36354 void *argp2 = 0 ;
36355 int res2 = 0 ;
36356 PyObject * obj0 = 0 ;
36357 PyObject * obj1 = 0 ;
36358 char * kwnames[] = {
36359 (char *) "self",(char *) "font", NULL
36360 };
36361
36362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
36363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36364 if (!SWIG_IsOK(res1)) {
36365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36366 }
36367 arg1 = reinterpret_cast< wxWindow * >(argp1);
36368 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36369 if (!SWIG_IsOK(res2)) {
36370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36371 }
36372 if (!argp2) {
36373 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36374 }
36375 arg2 = reinterpret_cast< wxFont * >(argp2);
36376 {
36377 PyThreadState* __tstate = wxPyBeginAllowThreads();
36378 (arg1)->SetOwnFont((wxFont const &)*arg2);
36379 wxPyEndAllowThreads(__tstate);
36380 if (PyErr_Occurred()) SWIG_fail;
36381 }
36382 resultobj = SWIG_Py_Void();
36383 return resultobj;
36384 fail:
36385 return NULL;
36386 }
36387
36388
36389 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36390 PyObject *resultobj = 0;
36391 wxWindow *arg1 = (wxWindow *) 0 ;
36392 wxFont result;
36393 void *argp1 = 0 ;
36394 int res1 = 0 ;
36395 PyObject *swig_obj[1] ;
36396
36397 if (!args) SWIG_fail;
36398 swig_obj[0] = args;
36399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36400 if (!SWIG_IsOK(res1)) {
36401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36402 }
36403 arg1 = reinterpret_cast< wxWindow * >(argp1);
36404 {
36405 PyThreadState* __tstate = wxPyBeginAllowThreads();
36406 result = (arg1)->GetFont();
36407 wxPyEndAllowThreads(__tstate);
36408 if (PyErr_Occurred()) SWIG_fail;
36409 }
36410 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
36411 return resultobj;
36412 fail:
36413 return NULL;
36414 }
36415
36416
36417 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36418 PyObject *resultobj = 0;
36419 wxWindow *arg1 = (wxWindow *) 0 ;
36420 wxCaret *arg2 = (wxCaret *) 0 ;
36421 void *argp1 = 0 ;
36422 int res1 = 0 ;
36423 int res2 = 0 ;
36424 PyObject * obj0 = 0 ;
36425 PyObject * obj1 = 0 ;
36426 char * kwnames[] = {
36427 (char *) "self",(char *) "caret", NULL
36428 };
36429
36430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
36431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36432 if (!SWIG_IsOK(res1)) {
36433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36434 }
36435 arg1 = reinterpret_cast< wxWindow * >(argp1);
36436 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36437 if (!SWIG_IsOK(res2)) {
36438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36439 }
36440 {
36441 PyThreadState* __tstate = wxPyBeginAllowThreads();
36442 (arg1)->SetCaret(arg2);
36443 wxPyEndAllowThreads(__tstate);
36444 if (PyErr_Occurred()) SWIG_fail;
36445 }
36446 resultobj = SWIG_Py_Void();
36447 return resultobj;
36448 fail:
36449 return NULL;
36450 }
36451
36452
36453 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36454 PyObject *resultobj = 0;
36455 wxWindow *arg1 = (wxWindow *) 0 ;
36456 wxCaret *result = 0 ;
36457 void *argp1 = 0 ;
36458 int res1 = 0 ;
36459 PyObject *swig_obj[1] ;
36460
36461 if (!args) SWIG_fail;
36462 swig_obj[0] = args;
36463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36464 if (!SWIG_IsOK(res1)) {
36465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36466 }
36467 arg1 = reinterpret_cast< wxWindow * >(argp1);
36468 {
36469 PyThreadState* __tstate = wxPyBeginAllowThreads();
36470 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36471 wxPyEndAllowThreads(__tstate);
36472 if (PyErr_Occurred()) SWIG_fail;
36473 }
36474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36475 return resultobj;
36476 fail:
36477 return NULL;
36478 }
36479
36480
36481 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36482 PyObject *resultobj = 0;
36483 wxWindow *arg1 = (wxWindow *) 0 ;
36484 int result;
36485 void *argp1 = 0 ;
36486 int res1 = 0 ;
36487 PyObject *swig_obj[1] ;
36488
36489 if (!args) SWIG_fail;
36490 swig_obj[0] = args;
36491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36492 if (!SWIG_IsOK(res1)) {
36493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36494 }
36495 arg1 = reinterpret_cast< wxWindow * >(argp1);
36496 {
36497 PyThreadState* __tstate = wxPyBeginAllowThreads();
36498 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36499 wxPyEndAllowThreads(__tstate);
36500 if (PyErr_Occurred()) SWIG_fail;
36501 }
36502 resultobj = SWIG_From_int(static_cast< int >(result));
36503 return resultobj;
36504 fail:
36505 return NULL;
36506 }
36507
36508
36509 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36510 PyObject *resultobj = 0;
36511 wxWindow *arg1 = (wxWindow *) 0 ;
36512 int result;
36513 void *argp1 = 0 ;
36514 int res1 = 0 ;
36515 PyObject *swig_obj[1] ;
36516
36517 if (!args) SWIG_fail;
36518 swig_obj[0] = args;
36519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36520 if (!SWIG_IsOK(res1)) {
36521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36522 }
36523 arg1 = reinterpret_cast< wxWindow * >(argp1);
36524 {
36525 PyThreadState* __tstate = wxPyBeginAllowThreads();
36526 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36527 wxPyEndAllowThreads(__tstate);
36528 if (PyErr_Occurred()) SWIG_fail;
36529 }
36530 resultobj = SWIG_From_int(static_cast< int >(result));
36531 return resultobj;
36532 fail:
36533 return NULL;
36534 }
36535
36536
36537 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36538 PyObject *resultobj = 0;
36539 wxWindow *arg1 = (wxWindow *) 0 ;
36540 wxString *arg2 = 0 ;
36541 int *arg3 = (int *) 0 ;
36542 int *arg4 = (int *) 0 ;
36543 void *argp1 = 0 ;
36544 int res1 = 0 ;
36545 bool temp2 = false ;
36546 int temp3 ;
36547 int res3 = SWIG_TMPOBJ ;
36548 int temp4 ;
36549 int res4 = SWIG_TMPOBJ ;
36550 PyObject * obj0 = 0 ;
36551 PyObject * obj1 = 0 ;
36552 char * kwnames[] = {
36553 (char *) "self",(char *) "string", NULL
36554 };
36555
36556 arg3 = &temp3;
36557 arg4 = &temp4;
36558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36560 if (!SWIG_IsOK(res1)) {
36561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36562 }
36563 arg1 = reinterpret_cast< wxWindow * >(argp1);
36564 {
36565 arg2 = wxString_in_helper(obj1);
36566 if (arg2 == NULL) SWIG_fail;
36567 temp2 = true;
36568 }
36569 {
36570 PyThreadState* __tstate = wxPyBeginAllowThreads();
36571 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36572 wxPyEndAllowThreads(__tstate);
36573 if (PyErr_Occurred()) SWIG_fail;
36574 }
36575 resultobj = SWIG_Py_Void();
36576 if (SWIG_IsTmpObj(res3)) {
36577 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36578 } else {
36579 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36580 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36581 }
36582 if (SWIG_IsTmpObj(res4)) {
36583 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36584 } else {
36585 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36586 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36587 }
36588 {
36589 if (temp2)
36590 delete arg2;
36591 }
36592 return resultobj;
36593 fail:
36594 {
36595 if (temp2)
36596 delete arg2;
36597 }
36598 return NULL;
36599 }
36600
36601
36602 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36603 PyObject *resultobj = 0;
36604 wxWindow *arg1 = (wxWindow *) 0 ;
36605 wxString *arg2 = 0 ;
36606 int *arg3 = (int *) 0 ;
36607 int *arg4 = (int *) 0 ;
36608 int *arg5 = (int *) 0 ;
36609 int *arg6 = (int *) 0 ;
36610 wxFont *arg7 = (wxFont *) NULL ;
36611 void *argp1 = 0 ;
36612 int res1 = 0 ;
36613 bool temp2 = false ;
36614 int temp3 ;
36615 int res3 = SWIG_TMPOBJ ;
36616 int temp4 ;
36617 int res4 = SWIG_TMPOBJ ;
36618 int temp5 ;
36619 int res5 = SWIG_TMPOBJ ;
36620 int temp6 ;
36621 int res6 = SWIG_TMPOBJ ;
36622 void *argp7 = 0 ;
36623 int res7 = 0 ;
36624 PyObject * obj0 = 0 ;
36625 PyObject * obj1 = 0 ;
36626 PyObject * obj2 = 0 ;
36627 char * kwnames[] = {
36628 (char *) "self",(char *) "string",(char *) "font", NULL
36629 };
36630
36631 arg3 = &temp3;
36632 arg4 = &temp4;
36633 arg5 = &temp5;
36634 arg6 = &temp6;
36635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36637 if (!SWIG_IsOK(res1)) {
36638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36639 }
36640 arg1 = reinterpret_cast< wxWindow * >(argp1);
36641 {
36642 arg2 = wxString_in_helper(obj1);
36643 if (arg2 == NULL) SWIG_fail;
36644 temp2 = true;
36645 }
36646 if (obj2) {
36647 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36648 if (!SWIG_IsOK(res7)) {
36649 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36650 }
36651 arg7 = reinterpret_cast< wxFont * >(argp7);
36652 }
36653 {
36654 PyThreadState* __tstate = wxPyBeginAllowThreads();
36655 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36656 wxPyEndAllowThreads(__tstate);
36657 if (PyErr_Occurred()) SWIG_fail;
36658 }
36659 resultobj = SWIG_Py_Void();
36660 if (SWIG_IsTmpObj(res3)) {
36661 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36662 } else {
36663 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36664 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36665 }
36666 if (SWIG_IsTmpObj(res4)) {
36667 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36668 } else {
36669 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36670 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36671 }
36672 if (SWIG_IsTmpObj(res5)) {
36673 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36674 } else {
36675 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36676 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36677 }
36678 if (SWIG_IsTmpObj(res6)) {
36679 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36680 } else {
36681 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36682 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36683 }
36684 {
36685 if (temp2)
36686 delete arg2;
36687 }
36688 return resultobj;
36689 fail:
36690 {
36691 if (temp2)
36692 delete arg2;
36693 }
36694 return NULL;
36695 }
36696
36697
36698 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36699 PyObject *resultobj = 0;
36700 wxWindow *arg1 = (wxWindow *) 0 ;
36701 int *arg2 = (int *) 0 ;
36702 int *arg3 = (int *) 0 ;
36703 void *argp1 = 0 ;
36704 int res1 = 0 ;
36705 int temp2 ;
36706 int res2 = 0 ;
36707 int temp3 ;
36708 int res3 = 0 ;
36709 PyObject * obj0 = 0 ;
36710 PyObject * obj1 = 0 ;
36711 PyObject * obj2 = 0 ;
36712 char * kwnames[] = {
36713 (char *) "self",(char *) "x",(char *) "y", NULL
36714 };
36715
36716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36718 if (!SWIG_IsOK(res1)) {
36719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36720 }
36721 arg1 = reinterpret_cast< wxWindow * >(argp1);
36722 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36723 int val;
36724 int ecode = SWIG_AsVal_int(obj1, &val);
36725 if (!SWIG_IsOK(ecode)) {
36726 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36727 }
36728 temp2 = static_cast< int >(val);
36729 arg2 = &temp2;
36730 res2 = SWIG_AddTmpMask(ecode);
36731 }
36732 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36733 int val;
36734 int ecode = SWIG_AsVal_int(obj2, &val);
36735 if (!SWIG_IsOK(ecode)) {
36736 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36737 }
36738 temp3 = static_cast< int >(val);
36739 arg3 = &temp3;
36740 res3 = SWIG_AddTmpMask(ecode);
36741 }
36742 {
36743 PyThreadState* __tstate = wxPyBeginAllowThreads();
36744 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36745 wxPyEndAllowThreads(__tstate);
36746 if (PyErr_Occurred()) SWIG_fail;
36747 }
36748 resultobj = SWIG_Py_Void();
36749 if (SWIG_IsTmpObj(res2)) {
36750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36751 } else {
36752 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36754 }
36755 if (SWIG_IsTmpObj(res3)) {
36756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36757 } else {
36758 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36760 }
36761 return resultobj;
36762 fail:
36763 return NULL;
36764 }
36765
36766
36767 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36768 PyObject *resultobj = 0;
36769 wxWindow *arg1 = (wxWindow *) 0 ;
36770 int *arg2 = (int *) 0 ;
36771 int *arg3 = (int *) 0 ;
36772 void *argp1 = 0 ;
36773 int res1 = 0 ;
36774 int temp2 ;
36775 int res2 = 0 ;
36776 int temp3 ;
36777 int res3 = 0 ;
36778 PyObject * obj0 = 0 ;
36779 PyObject * obj1 = 0 ;
36780 PyObject * obj2 = 0 ;
36781 char * kwnames[] = {
36782 (char *) "self",(char *) "x",(char *) "y", NULL
36783 };
36784
36785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36787 if (!SWIG_IsOK(res1)) {
36788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36789 }
36790 arg1 = reinterpret_cast< wxWindow * >(argp1);
36791 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36792 int val;
36793 int ecode = SWIG_AsVal_int(obj1, &val);
36794 if (!SWIG_IsOK(ecode)) {
36795 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36796 }
36797 temp2 = static_cast< int >(val);
36798 arg2 = &temp2;
36799 res2 = SWIG_AddTmpMask(ecode);
36800 }
36801 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36802 int val;
36803 int ecode = SWIG_AsVal_int(obj2, &val);
36804 if (!SWIG_IsOK(ecode)) {
36805 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36806 }
36807 temp3 = static_cast< int >(val);
36808 arg3 = &temp3;
36809 res3 = SWIG_AddTmpMask(ecode);
36810 }
36811 {
36812 PyThreadState* __tstate = wxPyBeginAllowThreads();
36813 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36814 wxPyEndAllowThreads(__tstate);
36815 if (PyErr_Occurred()) SWIG_fail;
36816 }
36817 resultobj = SWIG_Py_Void();
36818 if (SWIG_IsTmpObj(res2)) {
36819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36820 } else {
36821 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36823 }
36824 if (SWIG_IsTmpObj(res3)) {
36825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36826 } else {
36827 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36829 }
36830 return resultobj;
36831 fail:
36832 return NULL;
36833 }
36834
36835
36836 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36837 PyObject *resultobj = 0;
36838 wxWindow *arg1 = (wxWindow *) 0 ;
36839 wxPoint *arg2 = 0 ;
36840 wxPoint result;
36841 void *argp1 = 0 ;
36842 int res1 = 0 ;
36843 wxPoint temp2 ;
36844 PyObject * obj0 = 0 ;
36845 PyObject * obj1 = 0 ;
36846 char * kwnames[] = {
36847 (char *) "self",(char *) "pt", NULL
36848 };
36849
36850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
36851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36852 if (!SWIG_IsOK(res1)) {
36853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36854 }
36855 arg1 = reinterpret_cast< wxWindow * >(argp1);
36856 {
36857 arg2 = &temp2;
36858 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36859 }
36860 {
36861 PyThreadState* __tstate = wxPyBeginAllowThreads();
36862 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36863 wxPyEndAllowThreads(__tstate);
36864 if (PyErr_Occurred()) SWIG_fail;
36865 }
36866 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36867 return resultobj;
36868 fail:
36869 return NULL;
36870 }
36871
36872
36873 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36874 PyObject *resultobj = 0;
36875 wxWindow *arg1 = (wxWindow *) 0 ;
36876 wxPoint *arg2 = 0 ;
36877 wxPoint result;
36878 void *argp1 = 0 ;
36879 int res1 = 0 ;
36880 wxPoint temp2 ;
36881 PyObject * obj0 = 0 ;
36882 PyObject * obj1 = 0 ;
36883 char * kwnames[] = {
36884 (char *) "self",(char *) "pt", NULL
36885 };
36886
36887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36889 if (!SWIG_IsOK(res1)) {
36890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36891 }
36892 arg1 = reinterpret_cast< wxWindow * >(argp1);
36893 {
36894 arg2 = &temp2;
36895 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36896 }
36897 {
36898 PyThreadState* __tstate = wxPyBeginAllowThreads();
36899 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36900 wxPyEndAllowThreads(__tstate);
36901 if (PyErr_Occurred()) SWIG_fail;
36902 }
36903 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36904 return resultobj;
36905 fail:
36906 return NULL;
36907 }
36908
36909
36910 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36911 PyObject *resultobj = 0;
36912 wxWindow *arg1 = (wxWindow *) 0 ;
36913 int arg2 ;
36914 int arg3 ;
36915 wxHitTest result;
36916 void *argp1 = 0 ;
36917 int res1 = 0 ;
36918 int val2 ;
36919 int ecode2 = 0 ;
36920 int val3 ;
36921 int ecode3 = 0 ;
36922 PyObject * obj0 = 0 ;
36923 PyObject * obj1 = 0 ;
36924 PyObject * obj2 = 0 ;
36925 char * kwnames[] = {
36926 (char *) "self",(char *) "x",(char *) "y", NULL
36927 };
36928
36929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36931 if (!SWIG_IsOK(res1)) {
36932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36933 }
36934 arg1 = reinterpret_cast< wxWindow * >(argp1);
36935 ecode2 = SWIG_AsVal_int(obj1, &val2);
36936 if (!SWIG_IsOK(ecode2)) {
36937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36938 }
36939 arg2 = static_cast< int >(val2);
36940 ecode3 = SWIG_AsVal_int(obj2, &val3);
36941 if (!SWIG_IsOK(ecode3)) {
36942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36943 }
36944 arg3 = static_cast< int >(val3);
36945 {
36946 PyThreadState* __tstate = wxPyBeginAllowThreads();
36947 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36948 wxPyEndAllowThreads(__tstate);
36949 if (PyErr_Occurred()) SWIG_fail;
36950 }
36951 resultobj = SWIG_From_int(static_cast< int >(result));
36952 return resultobj;
36953 fail:
36954 return NULL;
36955 }
36956
36957
36958 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36959 PyObject *resultobj = 0;
36960 wxWindow *arg1 = (wxWindow *) 0 ;
36961 wxPoint *arg2 = 0 ;
36962 wxHitTest result;
36963 void *argp1 = 0 ;
36964 int res1 = 0 ;
36965 wxPoint temp2 ;
36966 PyObject * obj0 = 0 ;
36967 PyObject * obj1 = 0 ;
36968 char * kwnames[] = {
36969 (char *) "self",(char *) "pt", NULL
36970 };
36971
36972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36974 if (!SWIG_IsOK(res1)) {
36975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36976 }
36977 arg1 = reinterpret_cast< wxWindow * >(argp1);
36978 {
36979 arg2 = &temp2;
36980 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36981 }
36982 {
36983 PyThreadState* __tstate = wxPyBeginAllowThreads();
36984 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36985 wxPyEndAllowThreads(__tstate);
36986 if (PyErr_Occurred()) SWIG_fail;
36987 }
36988 resultobj = SWIG_From_int(static_cast< int >(result));
36989 return resultobj;
36990 fail:
36991 return NULL;
36992 }
36993
36994
36995 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36996 PyObject *resultobj = 0;
36997 wxWindow *arg1 = (wxWindow *) 0 ;
36998 long arg2 ;
36999 wxBorder result;
37000 void *argp1 = 0 ;
37001 int res1 = 0 ;
37002 long val2 ;
37003 int ecode2 = 0 ;
37004
37005 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
37006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37007 if (!SWIG_IsOK(res1)) {
37008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37009 }
37010 arg1 = reinterpret_cast< wxWindow * >(argp1);
37011 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
37012 if (!SWIG_IsOK(ecode2)) {
37013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
37014 }
37015 arg2 = static_cast< long >(val2);
37016 {
37017 PyThreadState* __tstate = wxPyBeginAllowThreads();
37018 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
37019 wxPyEndAllowThreads(__tstate);
37020 if (PyErr_Occurred()) SWIG_fail;
37021 }
37022 resultobj = SWIG_From_int(static_cast< int >(result));
37023 return resultobj;
37024 fail:
37025 return NULL;
37026 }
37027
37028
37029 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37030 PyObject *resultobj = 0;
37031 wxWindow *arg1 = (wxWindow *) 0 ;
37032 wxBorder result;
37033 void *argp1 = 0 ;
37034 int res1 = 0 ;
37035
37036 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
37037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37038 if (!SWIG_IsOK(res1)) {
37039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37040 }
37041 arg1 = reinterpret_cast< wxWindow * >(argp1);
37042 {
37043 PyThreadState* __tstate = wxPyBeginAllowThreads();
37044 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
37045 wxPyEndAllowThreads(__tstate);
37046 if (PyErr_Occurred()) SWIG_fail;
37047 }
37048 resultobj = SWIG_From_int(static_cast< int >(result));
37049 return resultobj;
37050 fail:
37051 return NULL;
37052 }
37053
37054
37055 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
37056 int argc;
37057 PyObject *argv[3];
37058
37059 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
37060 --argc;
37061 if (argc == 1) {
37062 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
37063 }
37064 if (argc == 2) {
37065 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
37066 }
37067
37068 fail:
37069 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
37070 return NULL;
37071 }
37072
37073
37074 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37075 PyObject *resultobj = 0;
37076 wxWindow *arg1 = (wxWindow *) 0 ;
37077 long arg2 = (long) wxUPDATE_UI_NONE ;
37078 void *argp1 = 0 ;
37079 int res1 = 0 ;
37080 long val2 ;
37081 int ecode2 = 0 ;
37082 PyObject * obj0 = 0 ;
37083 PyObject * obj1 = 0 ;
37084 char * kwnames[] = {
37085 (char *) "self",(char *) "flags", NULL
37086 };
37087
37088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
37089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37090 if (!SWIG_IsOK(res1)) {
37091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
37092 }
37093 arg1 = reinterpret_cast< wxWindow * >(argp1);
37094 if (obj1) {
37095 ecode2 = SWIG_AsVal_long(obj1, &val2);
37096 if (!SWIG_IsOK(ecode2)) {
37097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
37098 }
37099 arg2 = static_cast< long >(val2);
37100 }
37101 {
37102 PyThreadState* __tstate = wxPyBeginAllowThreads();
37103 (arg1)->UpdateWindowUI(arg2);
37104 wxPyEndAllowThreads(__tstate);
37105 if (PyErr_Occurred()) SWIG_fail;
37106 }
37107 resultobj = SWIG_Py_Void();
37108 return resultobj;
37109 fail:
37110 return NULL;
37111 }
37112
37113
37114 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37115 PyObject *resultobj = 0;
37116 wxWindow *arg1 = (wxWindow *) 0 ;
37117 wxMenu *arg2 = (wxMenu *) 0 ;
37118 int arg3 = (int) -1 ;
37119 int arg4 = (int) -1 ;
37120 bool result;
37121 void *argp1 = 0 ;
37122 int res1 = 0 ;
37123 void *argp2 = 0 ;
37124 int res2 = 0 ;
37125 int val3 ;
37126 int ecode3 = 0 ;
37127 int val4 ;
37128 int ecode4 = 0 ;
37129 PyObject * obj0 = 0 ;
37130 PyObject * obj1 = 0 ;
37131 PyObject * obj2 = 0 ;
37132 PyObject * obj3 = 0 ;
37133 char * kwnames[] = {
37134 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
37135 };
37136
37137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37139 if (!SWIG_IsOK(res1)) {
37140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
37141 }
37142 arg1 = reinterpret_cast< wxWindow * >(argp1);
37143 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37144 if (!SWIG_IsOK(res2)) {
37145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
37146 }
37147 arg2 = reinterpret_cast< wxMenu * >(argp2);
37148 if (obj2) {
37149 ecode3 = SWIG_AsVal_int(obj2, &val3);
37150 if (!SWIG_IsOK(ecode3)) {
37151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
37152 }
37153 arg3 = static_cast< int >(val3);
37154 }
37155 if (obj3) {
37156 ecode4 = SWIG_AsVal_int(obj3, &val4);
37157 if (!SWIG_IsOK(ecode4)) {
37158 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
37159 }
37160 arg4 = static_cast< int >(val4);
37161 }
37162 {
37163 PyThreadState* __tstate = wxPyBeginAllowThreads();
37164 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
37165 wxPyEndAllowThreads(__tstate);
37166 if (PyErr_Occurred()) SWIG_fail;
37167 }
37168 {
37169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37170 }
37171 return resultobj;
37172 fail:
37173 return NULL;
37174 }
37175
37176
37177 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37178 PyObject *resultobj = 0;
37179 wxWindow *arg1 = (wxWindow *) 0 ;
37180 wxMenu *arg2 = (wxMenu *) 0 ;
37181 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37182 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37183 bool result;
37184 void *argp1 = 0 ;
37185 int res1 = 0 ;
37186 void *argp2 = 0 ;
37187 int res2 = 0 ;
37188 wxPoint temp3 ;
37189 PyObject * obj0 = 0 ;
37190 PyObject * obj1 = 0 ;
37191 PyObject * obj2 = 0 ;
37192 char * kwnames[] = {
37193 (char *) "self",(char *) "menu",(char *) "pos", NULL
37194 };
37195
37196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37198 if (!SWIG_IsOK(res1)) {
37199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
37200 }
37201 arg1 = reinterpret_cast< wxWindow * >(argp1);
37202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37203 if (!SWIG_IsOK(res2)) {
37204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
37205 }
37206 arg2 = reinterpret_cast< wxMenu * >(argp2);
37207 if (obj2) {
37208 {
37209 arg3 = &temp3;
37210 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37211 }
37212 }
37213 {
37214 PyThreadState* __tstate = wxPyBeginAllowThreads();
37215 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
37216 wxPyEndAllowThreads(__tstate);
37217 if (PyErr_Occurred()) SWIG_fail;
37218 }
37219 {
37220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37221 }
37222 return resultobj;
37223 fail:
37224 return NULL;
37225 }
37226
37227
37228 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37229 PyObject *resultobj = 0;
37230 wxWindow *arg1 = (wxWindow *) 0 ;
37231 bool result;
37232 void *argp1 = 0 ;
37233 int res1 = 0 ;
37234 PyObject *swig_obj[1] ;
37235
37236 if (!args) SWIG_fail;
37237 swig_obj[0] = args;
37238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37239 if (!SWIG_IsOK(res1)) {
37240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
37241 }
37242 arg1 = reinterpret_cast< wxWindow * >(argp1);
37243 {
37244 PyThreadState* __tstate = wxPyBeginAllowThreads();
37245 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
37246 wxPyEndAllowThreads(__tstate);
37247 if (PyErr_Occurred()) SWIG_fail;
37248 }
37249 {
37250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37251 }
37252 return resultobj;
37253 fail:
37254 return NULL;
37255 }
37256
37257
37258 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37259 PyObject *resultobj = 0;
37260 wxWindow *arg1 = (wxWindow *) 0 ;
37261 long result;
37262 void *argp1 = 0 ;
37263 int res1 = 0 ;
37264 PyObject *swig_obj[1] ;
37265
37266 if (!args) SWIG_fail;
37267 swig_obj[0] = args;
37268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37269 if (!SWIG_IsOK(res1)) {
37270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37271 }
37272 arg1 = reinterpret_cast< wxWindow * >(argp1);
37273 {
37274 PyThreadState* __tstate = wxPyBeginAllowThreads();
37275 result = (long)wxWindow_GetHandle(arg1);
37276 wxPyEndAllowThreads(__tstate);
37277 if (PyErr_Occurred()) SWIG_fail;
37278 }
37279 resultobj = SWIG_From_long(static_cast< long >(result));
37280 return resultobj;
37281 fail:
37282 return NULL;
37283 }
37284
37285
37286 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37287 PyObject *resultobj = 0;
37288 wxWindow *arg1 = (wxWindow *) 0 ;
37289 long arg2 ;
37290 void *argp1 = 0 ;
37291 int res1 = 0 ;
37292 long val2 ;
37293 int ecode2 = 0 ;
37294 PyObject * obj0 = 0 ;
37295 PyObject * obj1 = 0 ;
37296 char * kwnames[] = {
37297 (char *) "self",(char *) "handle", NULL
37298 };
37299
37300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
37301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37302 if (!SWIG_IsOK(res1)) {
37303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37304 }
37305 arg1 = reinterpret_cast< wxWindow * >(argp1);
37306 ecode2 = SWIG_AsVal_long(obj1, &val2);
37307 if (!SWIG_IsOK(ecode2)) {
37308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
37309 }
37310 arg2 = static_cast< long >(val2);
37311 {
37312 PyThreadState* __tstate = wxPyBeginAllowThreads();
37313 wxWindow_AssociateHandle(arg1,arg2);
37314 wxPyEndAllowThreads(__tstate);
37315 if (PyErr_Occurred()) SWIG_fail;
37316 }
37317 resultobj = SWIG_Py_Void();
37318 return resultobj;
37319 fail:
37320 return NULL;
37321 }
37322
37323
37324 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37325 PyObject *resultobj = 0;
37326 wxWindow *arg1 = (wxWindow *) 0 ;
37327 void *argp1 = 0 ;
37328 int res1 = 0 ;
37329 PyObject *swig_obj[1] ;
37330
37331 if (!args) SWIG_fail;
37332 swig_obj[0] = args;
37333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37334 if (!SWIG_IsOK(res1)) {
37335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37336 }
37337 arg1 = reinterpret_cast< wxWindow * >(argp1);
37338 {
37339 PyThreadState* __tstate = wxPyBeginAllowThreads();
37340 (arg1)->DissociateHandle();
37341 wxPyEndAllowThreads(__tstate);
37342 if (PyErr_Occurred()) SWIG_fail;
37343 }
37344 resultobj = SWIG_Py_Void();
37345 return resultobj;
37346 fail:
37347 return NULL;
37348 }
37349
37350
37351 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37352 PyObject *resultobj = 0;
37353 wxWindow *arg1 = (wxWindow *) 0 ;
37354 wxPaintEvent *arg2 = 0 ;
37355 void *argp1 = 0 ;
37356 int res1 = 0 ;
37357 void *argp2 = 0 ;
37358 int res2 = 0 ;
37359 PyObject * obj0 = 0 ;
37360 PyObject * obj1 = 0 ;
37361 char * kwnames[] = {
37362 (char *) "self",(char *) "event", NULL
37363 };
37364
37365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
37366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37367 if (!SWIG_IsOK(res1)) {
37368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
37369 }
37370 arg1 = reinterpret_cast< wxWindow * >(argp1);
37371 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
37372 if (!SWIG_IsOK(res2)) {
37373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
37374 }
37375 if (!argp2) {
37376 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
37377 }
37378 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
37379 {
37380 PyThreadState* __tstate = wxPyBeginAllowThreads();
37381 (arg1)->OnPaint(*arg2);
37382 wxPyEndAllowThreads(__tstate);
37383 if (PyErr_Occurred()) SWIG_fail;
37384 }
37385 resultobj = SWIG_Py_Void();
37386 return resultobj;
37387 fail:
37388 return NULL;
37389 }
37390
37391
37392 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37393 PyObject *resultobj = 0;
37394 wxWindow *arg1 = (wxWindow *) 0 ;
37395 int arg2 ;
37396 bool result;
37397 void *argp1 = 0 ;
37398 int res1 = 0 ;
37399 int val2 ;
37400 int ecode2 = 0 ;
37401 PyObject * obj0 = 0 ;
37402 PyObject * obj1 = 0 ;
37403 char * kwnames[] = {
37404 (char *) "self",(char *) "orient", NULL
37405 };
37406
37407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
37408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37409 if (!SWIG_IsOK(res1)) {
37410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
37411 }
37412 arg1 = reinterpret_cast< wxWindow * >(argp1);
37413 ecode2 = SWIG_AsVal_int(obj1, &val2);
37414 if (!SWIG_IsOK(ecode2)) {
37415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
37416 }
37417 arg2 = static_cast< int >(val2);
37418 {
37419 PyThreadState* __tstate = wxPyBeginAllowThreads();
37420 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
37421 wxPyEndAllowThreads(__tstate);
37422 if (PyErr_Occurred()) SWIG_fail;
37423 }
37424 {
37425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37426 }
37427 return resultobj;
37428 fail:
37429 return NULL;
37430 }
37431
37432
37433 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37434 PyObject *resultobj = 0;
37435 wxWindow *arg1 = (wxWindow *) 0 ;
37436 int arg2 ;
37437 int arg3 ;
37438 int arg4 ;
37439 int arg5 ;
37440 bool arg6 = (bool) true ;
37441 void *argp1 = 0 ;
37442 int res1 = 0 ;
37443 int val2 ;
37444 int ecode2 = 0 ;
37445 int val3 ;
37446 int ecode3 = 0 ;
37447 int val4 ;
37448 int ecode4 = 0 ;
37449 int val5 ;
37450 int ecode5 = 0 ;
37451 bool val6 ;
37452 int ecode6 = 0 ;
37453 PyObject * obj0 = 0 ;
37454 PyObject * obj1 = 0 ;
37455 PyObject * obj2 = 0 ;
37456 PyObject * obj3 = 0 ;
37457 PyObject * obj4 = 0 ;
37458 PyObject * obj5 = 0 ;
37459 char * kwnames[] = {
37460 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37461 };
37462
37463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37465 if (!SWIG_IsOK(res1)) {
37466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37467 }
37468 arg1 = reinterpret_cast< wxWindow * >(argp1);
37469 ecode2 = SWIG_AsVal_int(obj1, &val2);
37470 if (!SWIG_IsOK(ecode2)) {
37471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37472 }
37473 arg2 = static_cast< int >(val2);
37474 ecode3 = SWIG_AsVal_int(obj2, &val3);
37475 if (!SWIG_IsOK(ecode3)) {
37476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37477 }
37478 arg3 = static_cast< int >(val3);
37479 ecode4 = SWIG_AsVal_int(obj3, &val4);
37480 if (!SWIG_IsOK(ecode4)) {
37481 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37482 }
37483 arg4 = static_cast< int >(val4);
37484 ecode5 = SWIG_AsVal_int(obj4, &val5);
37485 if (!SWIG_IsOK(ecode5)) {
37486 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37487 }
37488 arg5 = static_cast< int >(val5);
37489 if (obj5) {
37490 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37491 if (!SWIG_IsOK(ecode6)) {
37492 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37493 }
37494 arg6 = static_cast< bool >(val6);
37495 }
37496 {
37497 PyThreadState* __tstate = wxPyBeginAllowThreads();
37498 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37499 wxPyEndAllowThreads(__tstate);
37500 if (PyErr_Occurred()) SWIG_fail;
37501 }
37502 resultobj = SWIG_Py_Void();
37503 return resultobj;
37504 fail:
37505 return NULL;
37506 }
37507
37508
37509 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37510 PyObject *resultobj = 0;
37511 wxWindow *arg1 = (wxWindow *) 0 ;
37512 int arg2 ;
37513 int arg3 ;
37514 bool arg4 = (bool) true ;
37515 void *argp1 = 0 ;
37516 int res1 = 0 ;
37517 int val2 ;
37518 int ecode2 = 0 ;
37519 int val3 ;
37520 int ecode3 = 0 ;
37521 bool val4 ;
37522 int ecode4 = 0 ;
37523 PyObject * obj0 = 0 ;
37524 PyObject * obj1 = 0 ;
37525 PyObject * obj2 = 0 ;
37526 PyObject * obj3 = 0 ;
37527 char * kwnames[] = {
37528 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37529 };
37530
37531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37533 if (!SWIG_IsOK(res1)) {
37534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37535 }
37536 arg1 = reinterpret_cast< wxWindow * >(argp1);
37537 ecode2 = SWIG_AsVal_int(obj1, &val2);
37538 if (!SWIG_IsOK(ecode2)) {
37539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37540 }
37541 arg2 = static_cast< int >(val2);
37542 ecode3 = SWIG_AsVal_int(obj2, &val3);
37543 if (!SWIG_IsOK(ecode3)) {
37544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37545 }
37546 arg3 = static_cast< int >(val3);
37547 if (obj3) {
37548 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37549 if (!SWIG_IsOK(ecode4)) {
37550 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37551 }
37552 arg4 = static_cast< bool >(val4);
37553 }
37554 {
37555 PyThreadState* __tstate = wxPyBeginAllowThreads();
37556 (arg1)->SetScrollPos(arg2,arg3,arg4);
37557 wxPyEndAllowThreads(__tstate);
37558 if (PyErr_Occurred()) SWIG_fail;
37559 }
37560 resultobj = SWIG_Py_Void();
37561 return resultobj;
37562 fail:
37563 return NULL;
37564 }
37565
37566
37567 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37568 PyObject *resultobj = 0;
37569 wxWindow *arg1 = (wxWindow *) 0 ;
37570 int arg2 ;
37571 int result;
37572 void *argp1 = 0 ;
37573 int res1 = 0 ;
37574 int val2 ;
37575 int ecode2 = 0 ;
37576 PyObject * obj0 = 0 ;
37577 PyObject * obj1 = 0 ;
37578 char * kwnames[] = {
37579 (char *) "self",(char *) "orientation", NULL
37580 };
37581
37582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37584 if (!SWIG_IsOK(res1)) {
37585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37586 }
37587 arg1 = reinterpret_cast< wxWindow * >(argp1);
37588 ecode2 = SWIG_AsVal_int(obj1, &val2);
37589 if (!SWIG_IsOK(ecode2)) {
37590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37591 }
37592 arg2 = static_cast< int >(val2);
37593 {
37594 PyThreadState* __tstate = wxPyBeginAllowThreads();
37595 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37596 wxPyEndAllowThreads(__tstate);
37597 if (PyErr_Occurred()) SWIG_fail;
37598 }
37599 resultobj = SWIG_From_int(static_cast< int >(result));
37600 return resultobj;
37601 fail:
37602 return NULL;
37603 }
37604
37605
37606 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37607 PyObject *resultobj = 0;
37608 wxWindow *arg1 = (wxWindow *) 0 ;
37609 int arg2 ;
37610 int result;
37611 void *argp1 = 0 ;
37612 int res1 = 0 ;
37613 int val2 ;
37614 int ecode2 = 0 ;
37615 PyObject * obj0 = 0 ;
37616 PyObject * obj1 = 0 ;
37617 char * kwnames[] = {
37618 (char *) "self",(char *) "orientation", NULL
37619 };
37620
37621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37623 if (!SWIG_IsOK(res1)) {
37624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37625 }
37626 arg1 = reinterpret_cast< wxWindow * >(argp1);
37627 ecode2 = SWIG_AsVal_int(obj1, &val2);
37628 if (!SWIG_IsOK(ecode2)) {
37629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37630 }
37631 arg2 = static_cast< int >(val2);
37632 {
37633 PyThreadState* __tstate = wxPyBeginAllowThreads();
37634 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37635 wxPyEndAllowThreads(__tstate);
37636 if (PyErr_Occurred()) SWIG_fail;
37637 }
37638 resultobj = SWIG_From_int(static_cast< int >(result));
37639 return resultobj;
37640 fail:
37641 return NULL;
37642 }
37643
37644
37645 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37646 PyObject *resultobj = 0;
37647 wxWindow *arg1 = (wxWindow *) 0 ;
37648 int arg2 ;
37649 int result;
37650 void *argp1 = 0 ;
37651 int res1 = 0 ;
37652 int val2 ;
37653 int ecode2 = 0 ;
37654 PyObject * obj0 = 0 ;
37655 PyObject * obj1 = 0 ;
37656 char * kwnames[] = {
37657 (char *) "self",(char *) "orientation", NULL
37658 };
37659
37660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37662 if (!SWIG_IsOK(res1)) {
37663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37664 }
37665 arg1 = reinterpret_cast< wxWindow * >(argp1);
37666 ecode2 = SWIG_AsVal_int(obj1, &val2);
37667 if (!SWIG_IsOK(ecode2)) {
37668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37669 }
37670 arg2 = static_cast< int >(val2);
37671 {
37672 PyThreadState* __tstate = wxPyBeginAllowThreads();
37673 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37674 wxPyEndAllowThreads(__tstate);
37675 if (PyErr_Occurred()) SWIG_fail;
37676 }
37677 resultobj = SWIG_From_int(static_cast< int >(result));
37678 return resultobj;
37679 fail:
37680 return NULL;
37681 }
37682
37683
37684 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37685 PyObject *resultobj = 0;
37686 wxWindow *arg1 = (wxWindow *) 0 ;
37687 int arg2 ;
37688 int arg3 ;
37689 wxRect *arg4 = (wxRect *) NULL ;
37690 void *argp1 = 0 ;
37691 int res1 = 0 ;
37692 int val2 ;
37693 int ecode2 = 0 ;
37694 int val3 ;
37695 int ecode3 = 0 ;
37696 void *argp4 = 0 ;
37697 int res4 = 0 ;
37698 PyObject * obj0 = 0 ;
37699 PyObject * obj1 = 0 ;
37700 PyObject * obj2 = 0 ;
37701 PyObject * obj3 = 0 ;
37702 char * kwnames[] = {
37703 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37704 };
37705
37706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37708 if (!SWIG_IsOK(res1)) {
37709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37710 }
37711 arg1 = reinterpret_cast< wxWindow * >(argp1);
37712 ecode2 = SWIG_AsVal_int(obj1, &val2);
37713 if (!SWIG_IsOK(ecode2)) {
37714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37715 }
37716 arg2 = static_cast< int >(val2);
37717 ecode3 = SWIG_AsVal_int(obj2, &val3);
37718 if (!SWIG_IsOK(ecode3)) {
37719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37720 }
37721 arg3 = static_cast< int >(val3);
37722 if (obj3) {
37723 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37724 if (!SWIG_IsOK(res4)) {
37725 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37726 }
37727 arg4 = reinterpret_cast< wxRect * >(argp4);
37728 }
37729 {
37730 PyThreadState* __tstate = wxPyBeginAllowThreads();
37731 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37732 wxPyEndAllowThreads(__tstate);
37733 if (PyErr_Occurred()) SWIG_fail;
37734 }
37735 resultobj = SWIG_Py_Void();
37736 return resultobj;
37737 fail:
37738 return NULL;
37739 }
37740
37741
37742 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37743 PyObject *resultobj = 0;
37744 wxWindow *arg1 = (wxWindow *) 0 ;
37745 int arg2 ;
37746 bool result;
37747 void *argp1 = 0 ;
37748 int res1 = 0 ;
37749 int val2 ;
37750 int ecode2 = 0 ;
37751 PyObject * obj0 = 0 ;
37752 PyObject * obj1 = 0 ;
37753 char * kwnames[] = {
37754 (char *) "self",(char *) "lines", NULL
37755 };
37756
37757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37759 if (!SWIG_IsOK(res1)) {
37760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37761 }
37762 arg1 = reinterpret_cast< wxWindow * >(argp1);
37763 ecode2 = SWIG_AsVal_int(obj1, &val2);
37764 if (!SWIG_IsOK(ecode2)) {
37765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37766 }
37767 arg2 = static_cast< int >(val2);
37768 {
37769 PyThreadState* __tstate = wxPyBeginAllowThreads();
37770 result = (bool)(arg1)->ScrollLines(arg2);
37771 wxPyEndAllowThreads(__tstate);
37772 if (PyErr_Occurred()) SWIG_fail;
37773 }
37774 {
37775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37776 }
37777 return resultobj;
37778 fail:
37779 return NULL;
37780 }
37781
37782
37783 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37784 PyObject *resultobj = 0;
37785 wxWindow *arg1 = (wxWindow *) 0 ;
37786 int arg2 ;
37787 bool result;
37788 void *argp1 = 0 ;
37789 int res1 = 0 ;
37790 int val2 ;
37791 int ecode2 = 0 ;
37792 PyObject * obj0 = 0 ;
37793 PyObject * obj1 = 0 ;
37794 char * kwnames[] = {
37795 (char *) "self",(char *) "pages", NULL
37796 };
37797
37798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37800 if (!SWIG_IsOK(res1)) {
37801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37802 }
37803 arg1 = reinterpret_cast< wxWindow * >(argp1);
37804 ecode2 = SWIG_AsVal_int(obj1, &val2);
37805 if (!SWIG_IsOK(ecode2)) {
37806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37807 }
37808 arg2 = static_cast< int >(val2);
37809 {
37810 PyThreadState* __tstate = wxPyBeginAllowThreads();
37811 result = (bool)(arg1)->ScrollPages(arg2);
37812 wxPyEndAllowThreads(__tstate);
37813 if (PyErr_Occurred()) SWIG_fail;
37814 }
37815 {
37816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37817 }
37818 return resultobj;
37819 fail:
37820 return NULL;
37821 }
37822
37823
37824 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37825 PyObject *resultobj = 0;
37826 wxWindow *arg1 = (wxWindow *) 0 ;
37827 bool result;
37828 void *argp1 = 0 ;
37829 int res1 = 0 ;
37830 PyObject *swig_obj[1] ;
37831
37832 if (!args) SWIG_fail;
37833 swig_obj[0] = args;
37834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37835 if (!SWIG_IsOK(res1)) {
37836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37837 }
37838 arg1 = reinterpret_cast< wxWindow * >(argp1);
37839 {
37840 PyThreadState* __tstate = wxPyBeginAllowThreads();
37841 result = (bool)(arg1)->LineUp();
37842 wxPyEndAllowThreads(__tstate);
37843 if (PyErr_Occurred()) SWIG_fail;
37844 }
37845 {
37846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37847 }
37848 return resultobj;
37849 fail:
37850 return NULL;
37851 }
37852
37853
37854 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37855 PyObject *resultobj = 0;
37856 wxWindow *arg1 = (wxWindow *) 0 ;
37857 bool result;
37858 void *argp1 = 0 ;
37859 int res1 = 0 ;
37860 PyObject *swig_obj[1] ;
37861
37862 if (!args) SWIG_fail;
37863 swig_obj[0] = args;
37864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37865 if (!SWIG_IsOK(res1)) {
37866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37867 }
37868 arg1 = reinterpret_cast< wxWindow * >(argp1);
37869 {
37870 PyThreadState* __tstate = wxPyBeginAllowThreads();
37871 result = (bool)(arg1)->LineDown();
37872 wxPyEndAllowThreads(__tstate);
37873 if (PyErr_Occurred()) SWIG_fail;
37874 }
37875 {
37876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37877 }
37878 return resultobj;
37879 fail:
37880 return NULL;
37881 }
37882
37883
37884 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37885 PyObject *resultobj = 0;
37886 wxWindow *arg1 = (wxWindow *) 0 ;
37887 bool result;
37888 void *argp1 = 0 ;
37889 int res1 = 0 ;
37890 PyObject *swig_obj[1] ;
37891
37892 if (!args) SWIG_fail;
37893 swig_obj[0] = args;
37894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37895 if (!SWIG_IsOK(res1)) {
37896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37897 }
37898 arg1 = reinterpret_cast< wxWindow * >(argp1);
37899 {
37900 PyThreadState* __tstate = wxPyBeginAllowThreads();
37901 result = (bool)(arg1)->PageUp();
37902 wxPyEndAllowThreads(__tstate);
37903 if (PyErr_Occurred()) SWIG_fail;
37904 }
37905 {
37906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37907 }
37908 return resultobj;
37909 fail:
37910 return NULL;
37911 }
37912
37913
37914 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37915 PyObject *resultobj = 0;
37916 wxWindow *arg1 = (wxWindow *) 0 ;
37917 bool result;
37918 void *argp1 = 0 ;
37919 int res1 = 0 ;
37920 PyObject *swig_obj[1] ;
37921
37922 if (!args) SWIG_fail;
37923 swig_obj[0] = args;
37924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37925 if (!SWIG_IsOK(res1)) {
37926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37927 }
37928 arg1 = reinterpret_cast< wxWindow * >(argp1);
37929 {
37930 PyThreadState* __tstate = wxPyBeginAllowThreads();
37931 result = (bool)(arg1)->PageDown();
37932 wxPyEndAllowThreads(__tstate);
37933 if (PyErr_Occurred()) SWIG_fail;
37934 }
37935 {
37936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37937 }
37938 return resultobj;
37939 fail:
37940 return NULL;
37941 }
37942
37943
37944 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37945 PyObject *resultobj = 0;
37946 wxWindow *arg1 = (wxWindow *) 0 ;
37947 wxString *arg2 = 0 ;
37948 void *argp1 = 0 ;
37949 int res1 = 0 ;
37950 bool temp2 = false ;
37951 PyObject * obj0 = 0 ;
37952 PyObject * obj1 = 0 ;
37953 char * kwnames[] = {
37954 (char *) "self",(char *) "text", NULL
37955 };
37956
37957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37959 if (!SWIG_IsOK(res1)) {
37960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37961 }
37962 arg1 = reinterpret_cast< wxWindow * >(argp1);
37963 {
37964 arg2 = wxString_in_helper(obj1);
37965 if (arg2 == NULL) SWIG_fail;
37966 temp2 = true;
37967 }
37968 {
37969 PyThreadState* __tstate = wxPyBeginAllowThreads();
37970 (arg1)->SetHelpText((wxString const &)*arg2);
37971 wxPyEndAllowThreads(__tstate);
37972 if (PyErr_Occurred()) SWIG_fail;
37973 }
37974 resultobj = SWIG_Py_Void();
37975 {
37976 if (temp2)
37977 delete arg2;
37978 }
37979 return resultobj;
37980 fail:
37981 {
37982 if (temp2)
37983 delete arg2;
37984 }
37985 return NULL;
37986 }
37987
37988
37989 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37990 PyObject *resultobj = 0;
37991 wxWindow *arg1 = (wxWindow *) 0 ;
37992 wxString *arg2 = 0 ;
37993 void *argp1 = 0 ;
37994 int res1 = 0 ;
37995 bool temp2 = false ;
37996 PyObject * obj0 = 0 ;
37997 PyObject * obj1 = 0 ;
37998 char * kwnames[] = {
37999 (char *) "self",(char *) "text", NULL
38000 };
38001
38002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
38003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38004 if (!SWIG_IsOK(res1)) {
38005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
38006 }
38007 arg1 = reinterpret_cast< wxWindow * >(argp1);
38008 {
38009 arg2 = wxString_in_helper(obj1);
38010 if (arg2 == NULL) SWIG_fail;
38011 temp2 = true;
38012 }
38013 {
38014 PyThreadState* __tstate = wxPyBeginAllowThreads();
38015 (arg1)->SetHelpTextForId((wxString const &)*arg2);
38016 wxPyEndAllowThreads(__tstate);
38017 if (PyErr_Occurred()) SWIG_fail;
38018 }
38019 resultobj = SWIG_Py_Void();
38020 {
38021 if (temp2)
38022 delete arg2;
38023 }
38024 return resultobj;
38025 fail:
38026 {
38027 if (temp2)
38028 delete arg2;
38029 }
38030 return NULL;
38031 }
38032
38033
38034 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38035 PyObject *resultobj = 0;
38036 wxWindow *arg1 = (wxWindow *) 0 ;
38037 wxPoint *arg2 = 0 ;
38038 wxHelpEvent::Origin arg3 ;
38039 wxString result;
38040 void *argp1 = 0 ;
38041 int res1 = 0 ;
38042 wxPoint temp2 ;
38043 void *argp3 ;
38044 int res3 = 0 ;
38045 PyObject * obj0 = 0 ;
38046 PyObject * obj1 = 0 ;
38047 PyObject * obj2 = 0 ;
38048 char * kwnames[] = {
38049 (char *) "self",(char *) "pt",(char *) "origin", NULL
38050 };
38051
38052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38054 if (!SWIG_IsOK(res1)) {
38055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38056 }
38057 arg1 = reinterpret_cast< wxWindow * >(argp1);
38058 {
38059 arg2 = &temp2;
38060 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38061 }
38062 {
38063 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
38064 if (!SWIG_IsOK(res3)) {
38065 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38066 }
38067 if (!argp3) {
38068 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38069 } else {
38070 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
38071 arg3 = *temp;
38072 if (SWIG_IsNewObj(res3)) delete temp;
38073 }
38074 }
38075 {
38076 PyThreadState* __tstate = wxPyBeginAllowThreads();
38077 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
38078 wxPyEndAllowThreads(__tstate);
38079 if (PyErr_Occurred()) SWIG_fail;
38080 }
38081 {
38082 #if wxUSE_UNICODE
38083 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38084 #else
38085 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38086 #endif
38087 }
38088 return resultobj;
38089 fail:
38090 return NULL;
38091 }
38092
38093
38094 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38095 PyObject *resultobj = 0;
38096 wxWindow *arg1 = (wxWindow *) 0 ;
38097 wxString result;
38098 void *argp1 = 0 ;
38099 int res1 = 0 ;
38100 PyObject *swig_obj[1] ;
38101
38102 if (!args) SWIG_fail;
38103 swig_obj[0] = args;
38104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38105 if (!SWIG_IsOK(res1)) {
38106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
38107 }
38108 arg1 = reinterpret_cast< wxWindow * >(argp1);
38109 {
38110 PyThreadState* __tstate = wxPyBeginAllowThreads();
38111 result = ((wxWindow const *)arg1)->GetHelpText();
38112 wxPyEndAllowThreads(__tstate);
38113 if (PyErr_Occurred()) SWIG_fail;
38114 }
38115 {
38116 #if wxUSE_UNICODE
38117 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38118 #else
38119 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38120 #endif
38121 }
38122 return resultobj;
38123 fail:
38124 return NULL;
38125 }
38126
38127
38128 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38129 PyObject *resultobj = 0;
38130 wxWindow *arg1 = (wxWindow *) 0 ;
38131 wxString *arg2 = 0 ;
38132 void *argp1 = 0 ;
38133 int res1 = 0 ;
38134 bool temp2 = false ;
38135 PyObject * obj0 = 0 ;
38136 PyObject * obj1 = 0 ;
38137 char * kwnames[] = {
38138 (char *) "self",(char *) "tip", NULL
38139 };
38140
38141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
38142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38143 if (!SWIG_IsOK(res1)) {
38144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
38145 }
38146 arg1 = reinterpret_cast< wxWindow * >(argp1);
38147 {
38148 arg2 = wxString_in_helper(obj1);
38149 if (arg2 == NULL) SWIG_fail;
38150 temp2 = true;
38151 }
38152 {
38153 PyThreadState* __tstate = wxPyBeginAllowThreads();
38154 (arg1)->SetToolTip((wxString const &)*arg2);
38155 wxPyEndAllowThreads(__tstate);
38156 if (PyErr_Occurred()) SWIG_fail;
38157 }
38158 resultobj = SWIG_Py_Void();
38159 {
38160 if (temp2)
38161 delete arg2;
38162 }
38163 return resultobj;
38164 fail:
38165 {
38166 if (temp2)
38167 delete arg2;
38168 }
38169 return NULL;
38170 }
38171
38172
38173 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38174 PyObject *resultobj = 0;
38175 wxWindow *arg1 = (wxWindow *) 0 ;
38176 wxToolTip *arg2 = (wxToolTip *) 0 ;
38177 void *argp1 = 0 ;
38178 int res1 = 0 ;
38179 int res2 = 0 ;
38180 PyObject * obj0 = 0 ;
38181 PyObject * obj1 = 0 ;
38182 char * kwnames[] = {
38183 (char *) "self",(char *) "tip", NULL
38184 };
38185
38186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
38187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38188 if (!SWIG_IsOK(res1)) {
38189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
38190 }
38191 arg1 = reinterpret_cast< wxWindow * >(argp1);
38192 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
38193 if (!SWIG_IsOK(res2)) {
38194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
38195 }
38196 {
38197 PyThreadState* __tstate = wxPyBeginAllowThreads();
38198 (arg1)->SetToolTip(arg2);
38199 wxPyEndAllowThreads(__tstate);
38200 if (PyErr_Occurred()) SWIG_fail;
38201 }
38202 resultobj = SWIG_Py_Void();
38203 return resultobj;
38204 fail:
38205 return NULL;
38206 }
38207
38208
38209 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38210 PyObject *resultobj = 0;
38211 wxWindow *arg1 = (wxWindow *) 0 ;
38212 wxToolTip *result = 0 ;
38213 void *argp1 = 0 ;
38214 int res1 = 0 ;
38215 PyObject *swig_obj[1] ;
38216
38217 if (!args) SWIG_fail;
38218 swig_obj[0] = args;
38219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38220 if (!SWIG_IsOK(res1)) {
38221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
38222 }
38223 arg1 = reinterpret_cast< wxWindow * >(argp1);
38224 {
38225 PyThreadState* __tstate = wxPyBeginAllowThreads();
38226 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
38227 wxPyEndAllowThreads(__tstate);
38228 if (PyErr_Occurred()) SWIG_fail;
38229 }
38230 {
38231 resultobj = wxPyMake_wxObject(result, (bool)0);
38232 }
38233 return resultobj;
38234 fail:
38235 return NULL;
38236 }
38237
38238
38239 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38240 PyObject *resultobj = 0;
38241 wxWindow *arg1 = (wxWindow *) 0 ;
38242 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
38243 void *argp1 = 0 ;
38244 int res1 = 0 ;
38245 int res2 = 0 ;
38246 PyObject * obj0 = 0 ;
38247 PyObject * obj1 = 0 ;
38248 char * kwnames[] = {
38249 (char *) "self",(char *) "dropTarget", NULL
38250 };
38251
38252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
38253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38254 if (!SWIG_IsOK(res1)) {
38255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
38256 }
38257 arg1 = reinterpret_cast< wxWindow * >(argp1);
38258 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
38259 if (!SWIG_IsOK(res2)) {
38260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
38261 }
38262 {
38263 PyThreadState* __tstate = wxPyBeginAllowThreads();
38264 (arg1)->SetDropTarget(arg2);
38265 wxPyEndAllowThreads(__tstate);
38266 if (PyErr_Occurred()) SWIG_fail;
38267 }
38268 resultobj = SWIG_Py_Void();
38269 return resultobj;
38270 fail:
38271 return NULL;
38272 }
38273
38274
38275 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38276 PyObject *resultobj = 0;
38277 wxWindow *arg1 = (wxWindow *) 0 ;
38278 wxPyDropTarget *result = 0 ;
38279 void *argp1 = 0 ;
38280 int res1 = 0 ;
38281 PyObject *swig_obj[1] ;
38282
38283 if (!args) SWIG_fail;
38284 swig_obj[0] = args;
38285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38286 if (!SWIG_IsOK(res1)) {
38287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
38288 }
38289 arg1 = reinterpret_cast< wxWindow * >(argp1);
38290 {
38291 PyThreadState* __tstate = wxPyBeginAllowThreads();
38292 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
38293 wxPyEndAllowThreads(__tstate);
38294 if (PyErr_Occurred()) SWIG_fail;
38295 }
38296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
38297 return resultobj;
38298 fail:
38299 return NULL;
38300 }
38301
38302
38303 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38304 PyObject *resultobj = 0;
38305 wxWindow *arg1 = (wxWindow *) 0 ;
38306 bool arg2 ;
38307 void *argp1 = 0 ;
38308 int res1 = 0 ;
38309 bool val2 ;
38310 int ecode2 = 0 ;
38311 PyObject * obj0 = 0 ;
38312 PyObject * obj1 = 0 ;
38313 char * kwnames[] = {
38314 (char *) "self",(char *) "accept", NULL
38315 };
38316
38317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
38318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38319 if (!SWIG_IsOK(res1)) {
38320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
38321 }
38322 arg1 = reinterpret_cast< wxWindow * >(argp1);
38323 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38324 if (!SWIG_IsOK(ecode2)) {
38325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
38326 }
38327 arg2 = static_cast< bool >(val2);
38328 {
38329 PyThreadState* __tstate = wxPyBeginAllowThreads();
38330 (arg1)->DragAcceptFiles(arg2);
38331 wxPyEndAllowThreads(__tstate);
38332 if (PyErr_Occurred()) SWIG_fail;
38333 }
38334 resultobj = SWIG_Py_Void();
38335 return resultobj;
38336 fail:
38337 return NULL;
38338 }
38339
38340
38341 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38342 PyObject *resultobj = 0;
38343 wxWindow *arg1 = (wxWindow *) 0 ;
38344 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
38345 void *argp1 = 0 ;
38346 int res1 = 0 ;
38347 int res2 = 0 ;
38348 PyObject * obj0 = 0 ;
38349 PyObject * obj1 = 0 ;
38350 char * kwnames[] = {
38351 (char *) "self",(char *) "constraints", NULL
38352 };
38353
38354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
38355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38356 if (!SWIG_IsOK(res1)) {
38357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
38358 }
38359 arg1 = reinterpret_cast< wxWindow * >(argp1);
38360 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
38361 if (!SWIG_IsOK(res2)) {
38362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
38363 }
38364 {
38365 PyThreadState* __tstate = wxPyBeginAllowThreads();
38366 (arg1)->SetConstraints(arg2);
38367 wxPyEndAllowThreads(__tstate);
38368 if (PyErr_Occurred()) SWIG_fail;
38369 }
38370 resultobj = SWIG_Py_Void();
38371 return resultobj;
38372 fail:
38373 return NULL;
38374 }
38375
38376
38377 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38378 PyObject *resultobj = 0;
38379 wxWindow *arg1 = (wxWindow *) 0 ;
38380 wxLayoutConstraints *result = 0 ;
38381 void *argp1 = 0 ;
38382 int res1 = 0 ;
38383 PyObject *swig_obj[1] ;
38384
38385 if (!args) SWIG_fail;
38386 swig_obj[0] = args;
38387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38388 if (!SWIG_IsOK(res1)) {
38389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
38390 }
38391 arg1 = reinterpret_cast< wxWindow * >(argp1);
38392 {
38393 PyThreadState* __tstate = wxPyBeginAllowThreads();
38394 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
38395 wxPyEndAllowThreads(__tstate);
38396 if (PyErr_Occurred()) SWIG_fail;
38397 }
38398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
38399 return resultobj;
38400 fail:
38401 return NULL;
38402 }
38403
38404
38405 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38406 PyObject *resultobj = 0;
38407 wxWindow *arg1 = (wxWindow *) 0 ;
38408 bool arg2 ;
38409 void *argp1 = 0 ;
38410 int res1 = 0 ;
38411 bool val2 ;
38412 int ecode2 = 0 ;
38413 PyObject * obj0 = 0 ;
38414 PyObject * obj1 = 0 ;
38415 char * kwnames[] = {
38416 (char *) "self",(char *) "autoLayout", NULL
38417 };
38418
38419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
38420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38421 if (!SWIG_IsOK(res1)) {
38422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
38423 }
38424 arg1 = reinterpret_cast< wxWindow * >(argp1);
38425 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38426 if (!SWIG_IsOK(ecode2)) {
38427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
38428 }
38429 arg2 = static_cast< bool >(val2);
38430 {
38431 PyThreadState* __tstate = wxPyBeginAllowThreads();
38432 (arg1)->SetAutoLayout(arg2);
38433 wxPyEndAllowThreads(__tstate);
38434 if (PyErr_Occurred()) SWIG_fail;
38435 }
38436 resultobj = SWIG_Py_Void();
38437 return resultobj;
38438 fail:
38439 return NULL;
38440 }
38441
38442
38443 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38444 PyObject *resultobj = 0;
38445 wxWindow *arg1 = (wxWindow *) 0 ;
38446 bool result;
38447 void *argp1 = 0 ;
38448 int res1 = 0 ;
38449 PyObject *swig_obj[1] ;
38450
38451 if (!args) SWIG_fail;
38452 swig_obj[0] = args;
38453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38454 if (!SWIG_IsOK(res1)) {
38455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
38456 }
38457 arg1 = reinterpret_cast< wxWindow * >(argp1);
38458 {
38459 PyThreadState* __tstate = wxPyBeginAllowThreads();
38460 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38461 wxPyEndAllowThreads(__tstate);
38462 if (PyErr_Occurred()) SWIG_fail;
38463 }
38464 {
38465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38466 }
38467 return resultobj;
38468 fail:
38469 return NULL;
38470 }
38471
38472
38473 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38474 PyObject *resultobj = 0;
38475 wxWindow *arg1 = (wxWindow *) 0 ;
38476 bool result;
38477 void *argp1 = 0 ;
38478 int res1 = 0 ;
38479 PyObject *swig_obj[1] ;
38480
38481 if (!args) SWIG_fail;
38482 swig_obj[0] = args;
38483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38484 if (!SWIG_IsOK(res1)) {
38485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38486 }
38487 arg1 = reinterpret_cast< wxWindow * >(argp1);
38488 {
38489 PyThreadState* __tstate = wxPyBeginAllowThreads();
38490 result = (bool)(arg1)->Layout();
38491 wxPyEndAllowThreads(__tstate);
38492 if (PyErr_Occurred()) SWIG_fail;
38493 }
38494 {
38495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38496 }
38497 return resultobj;
38498 fail:
38499 return NULL;
38500 }
38501
38502
38503 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38504 PyObject *resultobj = 0;
38505 wxWindow *arg1 = (wxWindow *) 0 ;
38506 wxSizer *arg2 = (wxSizer *) 0 ;
38507 bool arg3 = (bool) true ;
38508 void *argp1 = 0 ;
38509 int res1 = 0 ;
38510 int res2 = 0 ;
38511 bool val3 ;
38512 int ecode3 = 0 ;
38513 PyObject * obj0 = 0 ;
38514 PyObject * obj1 = 0 ;
38515 PyObject * obj2 = 0 ;
38516 char * kwnames[] = {
38517 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38518 };
38519
38520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38522 if (!SWIG_IsOK(res1)) {
38523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38524 }
38525 arg1 = reinterpret_cast< wxWindow * >(argp1);
38526 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38527 if (!SWIG_IsOK(res2)) {
38528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38529 }
38530 if (obj2) {
38531 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38532 if (!SWIG_IsOK(ecode3)) {
38533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38534 }
38535 arg3 = static_cast< bool >(val3);
38536 }
38537 {
38538 PyThreadState* __tstate = wxPyBeginAllowThreads();
38539 (arg1)->SetSizer(arg2,arg3);
38540 wxPyEndAllowThreads(__tstate);
38541 if (PyErr_Occurred()) SWIG_fail;
38542 }
38543 resultobj = SWIG_Py_Void();
38544 return resultobj;
38545 fail:
38546 return NULL;
38547 }
38548
38549
38550 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38551 PyObject *resultobj = 0;
38552 wxWindow *arg1 = (wxWindow *) 0 ;
38553 wxSizer *arg2 = (wxSizer *) 0 ;
38554 bool arg3 = (bool) true ;
38555 void *argp1 = 0 ;
38556 int res1 = 0 ;
38557 int res2 = 0 ;
38558 bool val3 ;
38559 int ecode3 = 0 ;
38560 PyObject * obj0 = 0 ;
38561 PyObject * obj1 = 0 ;
38562 PyObject * obj2 = 0 ;
38563 char * kwnames[] = {
38564 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38565 };
38566
38567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38569 if (!SWIG_IsOK(res1)) {
38570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38571 }
38572 arg1 = reinterpret_cast< wxWindow * >(argp1);
38573 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38574 if (!SWIG_IsOK(res2)) {
38575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38576 }
38577 if (obj2) {
38578 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38579 if (!SWIG_IsOK(ecode3)) {
38580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38581 }
38582 arg3 = static_cast< bool >(val3);
38583 }
38584 {
38585 PyThreadState* __tstate = wxPyBeginAllowThreads();
38586 (arg1)->SetSizerAndFit(arg2,arg3);
38587 wxPyEndAllowThreads(__tstate);
38588 if (PyErr_Occurred()) SWIG_fail;
38589 }
38590 resultobj = SWIG_Py_Void();
38591 return resultobj;
38592 fail:
38593 return NULL;
38594 }
38595
38596
38597 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38598 PyObject *resultobj = 0;
38599 wxWindow *arg1 = (wxWindow *) 0 ;
38600 wxSizer *result = 0 ;
38601 void *argp1 = 0 ;
38602 int res1 = 0 ;
38603 PyObject *swig_obj[1] ;
38604
38605 if (!args) SWIG_fail;
38606 swig_obj[0] = args;
38607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38608 if (!SWIG_IsOK(res1)) {
38609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38610 }
38611 arg1 = reinterpret_cast< wxWindow * >(argp1);
38612 {
38613 PyThreadState* __tstate = wxPyBeginAllowThreads();
38614 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38615 wxPyEndAllowThreads(__tstate);
38616 if (PyErr_Occurred()) SWIG_fail;
38617 }
38618 {
38619 resultobj = wxPyMake_wxObject(result, (bool)0);
38620 }
38621 return resultobj;
38622 fail:
38623 return NULL;
38624 }
38625
38626
38627 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38628 PyObject *resultobj = 0;
38629 wxWindow *arg1 = (wxWindow *) 0 ;
38630 wxSizer *arg2 = (wxSizer *) 0 ;
38631 void *argp1 = 0 ;
38632 int res1 = 0 ;
38633 void *argp2 = 0 ;
38634 int res2 = 0 ;
38635 PyObject * obj0 = 0 ;
38636 PyObject * obj1 = 0 ;
38637 char * kwnames[] = {
38638 (char *) "self",(char *) "sizer", NULL
38639 };
38640
38641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38643 if (!SWIG_IsOK(res1)) {
38644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38645 }
38646 arg1 = reinterpret_cast< wxWindow * >(argp1);
38647 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38648 if (!SWIG_IsOK(res2)) {
38649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38650 }
38651 arg2 = reinterpret_cast< wxSizer * >(argp2);
38652 {
38653 PyThreadState* __tstate = wxPyBeginAllowThreads();
38654 (arg1)->SetContainingSizer(arg2);
38655 wxPyEndAllowThreads(__tstate);
38656 if (PyErr_Occurred()) SWIG_fail;
38657 }
38658 resultobj = SWIG_Py_Void();
38659 return resultobj;
38660 fail:
38661 return NULL;
38662 }
38663
38664
38665 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38666 PyObject *resultobj = 0;
38667 wxWindow *arg1 = (wxWindow *) 0 ;
38668 wxSizer *result = 0 ;
38669 void *argp1 = 0 ;
38670 int res1 = 0 ;
38671 PyObject *swig_obj[1] ;
38672
38673 if (!args) SWIG_fail;
38674 swig_obj[0] = args;
38675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38676 if (!SWIG_IsOK(res1)) {
38677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38678 }
38679 arg1 = reinterpret_cast< wxWindow * >(argp1);
38680 {
38681 PyThreadState* __tstate = wxPyBeginAllowThreads();
38682 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38683 wxPyEndAllowThreads(__tstate);
38684 if (PyErr_Occurred()) SWIG_fail;
38685 }
38686 {
38687 resultobj = wxPyMake_wxObject(result, (bool)0);
38688 }
38689 return resultobj;
38690 fail:
38691 return NULL;
38692 }
38693
38694
38695 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38696 PyObject *resultobj = 0;
38697 wxWindow *arg1 = (wxWindow *) 0 ;
38698 void *argp1 = 0 ;
38699 int res1 = 0 ;
38700 PyObject *swig_obj[1] ;
38701
38702 if (!args) SWIG_fail;
38703 swig_obj[0] = args;
38704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38705 if (!SWIG_IsOK(res1)) {
38706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38707 }
38708 arg1 = reinterpret_cast< wxWindow * >(argp1);
38709 {
38710 PyThreadState* __tstate = wxPyBeginAllowThreads();
38711 (arg1)->InheritAttributes();
38712 wxPyEndAllowThreads(__tstate);
38713 if (PyErr_Occurred()) SWIG_fail;
38714 }
38715 resultobj = SWIG_Py_Void();
38716 return resultobj;
38717 fail:
38718 return NULL;
38719 }
38720
38721
38722 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38723 PyObject *resultobj = 0;
38724 wxWindow *arg1 = (wxWindow *) 0 ;
38725 bool result;
38726 void *argp1 = 0 ;
38727 int res1 = 0 ;
38728 PyObject *swig_obj[1] ;
38729
38730 if (!args) SWIG_fail;
38731 swig_obj[0] = args;
38732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38733 if (!SWIG_IsOK(res1)) {
38734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38735 }
38736 arg1 = reinterpret_cast< wxWindow * >(argp1);
38737 {
38738 PyThreadState* __tstate = wxPyBeginAllowThreads();
38739 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38740 wxPyEndAllowThreads(__tstate);
38741 if (PyErr_Occurred()) SWIG_fail;
38742 }
38743 {
38744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38745 }
38746 return resultobj;
38747 fail:
38748 return NULL;
38749 }
38750
38751
38752 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38753 PyObject *resultobj = 0;
38754 wxWindow *arg1 = (wxWindow *) 0 ;
38755 bool result;
38756 void *argp1 = 0 ;
38757 int res1 = 0 ;
38758 PyObject *swig_obj[1] ;
38759
38760 if (!args) SWIG_fail;
38761 swig_obj[0] = args;
38762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38763 if (!SWIG_IsOK(res1)) {
38764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38765 }
38766 arg1 = reinterpret_cast< wxWindow * >(argp1);
38767 {
38768 PyThreadState* __tstate = wxPyBeginAllowThreads();
38769 result = (bool)(arg1)->CanSetTransparent();
38770 wxPyEndAllowThreads(__tstate);
38771 if (PyErr_Occurred()) SWIG_fail;
38772 }
38773 {
38774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38775 }
38776 return resultobj;
38777 fail:
38778 return NULL;
38779 }
38780
38781
38782 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38783 PyObject *resultobj = 0;
38784 wxWindow *arg1 = (wxWindow *) 0 ;
38785 byte arg2 ;
38786 bool result;
38787 void *argp1 = 0 ;
38788 int res1 = 0 ;
38789 unsigned char val2 ;
38790 int ecode2 = 0 ;
38791 PyObject * obj0 = 0 ;
38792 PyObject * obj1 = 0 ;
38793 char * kwnames[] = {
38794 (char *) "self",(char *) "alpha", NULL
38795 };
38796
38797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",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_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38801 }
38802 arg1 = reinterpret_cast< wxWindow * >(argp1);
38803 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38804 if (!SWIG_IsOK(ecode2)) {
38805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38806 }
38807 arg2 = static_cast< byte >(val2);
38808 {
38809 PyThreadState* __tstate = wxPyBeginAllowThreads();
38810 result = (bool)(arg1)->SetTransparent(arg2);
38811 wxPyEndAllowThreads(__tstate);
38812 if (PyErr_Occurred()) SWIG_fail;
38813 }
38814 {
38815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38816 }
38817 return resultobj;
38818 fail:
38819 return NULL;
38820 }
38821
38822
38823 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38824 PyObject *obj;
38825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38826 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38827 return SWIG_Py_Void();
38828 }
38829
38830 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38831 return SWIG_Python_InitShadowInstance(args);
38832 }
38833
38834 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38835 PyObject *resultobj = 0;
38836 long arg1 ;
38837 wxWindow *arg2 = (wxWindow *) NULL ;
38838 wxWindow *result = 0 ;
38839 long val1 ;
38840 int ecode1 = 0 ;
38841 void *argp2 = 0 ;
38842 int res2 = 0 ;
38843 PyObject * obj0 = 0 ;
38844 PyObject * obj1 = 0 ;
38845 char * kwnames[] = {
38846 (char *) "id",(char *) "parent", NULL
38847 };
38848
38849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38850 ecode1 = SWIG_AsVal_long(obj0, &val1);
38851 if (!SWIG_IsOK(ecode1)) {
38852 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38853 }
38854 arg1 = static_cast< long >(val1);
38855 if (obj1) {
38856 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38857 if (!SWIG_IsOK(res2)) {
38858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38859 }
38860 arg2 = reinterpret_cast< wxWindow * >(argp2);
38861 }
38862 {
38863 if (!wxPyCheckForApp()) SWIG_fail;
38864 PyThreadState* __tstate = wxPyBeginAllowThreads();
38865 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38866 wxPyEndAllowThreads(__tstate);
38867 if (PyErr_Occurred()) SWIG_fail;
38868 }
38869 {
38870 resultobj = wxPyMake_wxObject(result, 0);
38871 }
38872 return resultobj;
38873 fail:
38874 return NULL;
38875 }
38876
38877
38878 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38879 PyObject *resultobj = 0;
38880 wxString *arg1 = 0 ;
38881 wxWindow *arg2 = (wxWindow *) NULL ;
38882 wxWindow *result = 0 ;
38883 bool temp1 = false ;
38884 void *argp2 = 0 ;
38885 int res2 = 0 ;
38886 PyObject * obj0 = 0 ;
38887 PyObject * obj1 = 0 ;
38888 char * kwnames[] = {
38889 (char *) "name",(char *) "parent", NULL
38890 };
38891
38892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38893 {
38894 arg1 = wxString_in_helper(obj0);
38895 if (arg1 == NULL) SWIG_fail;
38896 temp1 = true;
38897 }
38898 if (obj1) {
38899 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38900 if (!SWIG_IsOK(res2)) {
38901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38902 }
38903 arg2 = reinterpret_cast< wxWindow * >(argp2);
38904 }
38905 {
38906 if (!wxPyCheckForApp()) SWIG_fail;
38907 PyThreadState* __tstate = wxPyBeginAllowThreads();
38908 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38909 wxPyEndAllowThreads(__tstate);
38910 if (PyErr_Occurred()) SWIG_fail;
38911 }
38912 {
38913 resultobj = wxPyMake_wxObject(result, 0);
38914 }
38915 {
38916 if (temp1)
38917 delete arg1;
38918 }
38919 return resultobj;
38920 fail:
38921 {
38922 if (temp1)
38923 delete arg1;
38924 }
38925 return NULL;
38926 }
38927
38928
38929 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38930 PyObject *resultobj = 0;
38931 wxString *arg1 = 0 ;
38932 wxWindow *arg2 = (wxWindow *) NULL ;
38933 wxWindow *result = 0 ;
38934 bool temp1 = false ;
38935 void *argp2 = 0 ;
38936 int res2 = 0 ;
38937 PyObject * obj0 = 0 ;
38938 PyObject * obj1 = 0 ;
38939 char * kwnames[] = {
38940 (char *) "label",(char *) "parent", NULL
38941 };
38942
38943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38944 {
38945 arg1 = wxString_in_helper(obj0);
38946 if (arg1 == NULL) SWIG_fail;
38947 temp1 = true;
38948 }
38949 if (obj1) {
38950 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38951 if (!SWIG_IsOK(res2)) {
38952 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38953 }
38954 arg2 = reinterpret_cast< wxWindow * >(argp2);
38955 }
38956 {
38957 if (!wxPyCheckForApp()) SWIG_fail;
38958 PyThreadState* __tstate = wxPyBeginAllowThreads();
38959 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38960 wxPyEndAllowThreads(__tstate);
38961 if (PyErr_Occurred()) SWIG_fail;
38962 }
38963 {
38964 resultobj = wxPyMake_wxObject(result, 0);
38965 }
38966 {
38967 if (temp1)
38968 delete arg1;
38969 }
38970 return resultobj;
38971 fail:
38972 {
38973 if (temp1)
38974 delete arg1;
38975 }
38976 return NULL;
38977 }
38978
38979
38980 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38981 PyObject *resultobj = 0;
38982 wxWindow *arg1 = (wxWindow *) 0 ;
38983 unsigned long arg2 ;
38984 wxWindow *result = 0 ;
38985 void *argp1 = 0 ;
38986 int res1 = 0 ;
38987 unsigned long val2 ;
38988 int ecode2 = 0 ;
38989 PyObject * obj0 = 0 ;
38990 PyObject * obj1 = 0 ;
38991 char * kwnames[] = {
38992 (char *) "parent",(char *) "_hWnd", NULL
38993 };
38994
38995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38997 if (!SWIG_IsOK(res1)) {
38998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38999 }
39000 arg1 = reinterpret_cast< wxWindow * >(argp1);
39001 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
39002 if (!SWIG_IsOK(ecode2)) {
39003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
39004 }
39005 arg2 = static_cast< unsigned long >(val2);
39006 {
39007 PyThreadState* __tstate = wxPyBeginAllowThreads();
39008 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
39009 wxPyEndAllowThreads(__tstate);
39010 if (PyErr_Occurred()) SWIG_fail;
39011 }
39012 {
39013 resultobj = wxPyMake_wxObject(result, 0);
39014 }
39015 return resultobj;
39016 fail:
39017 return NULL;
39018 }
39019
39020
39021 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39022 PyObject *resultobj = 0;
39023 PyObject *result = 0 ;
39024
39025 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
39026 {
39027 PyThreadState* __tstate = wxPyBeginAllowThreads();
39028 result = (PyObject *)GetTopLevelWindows();
39029 wxPyEndAllowThreads(__tstate);
39030 if (PyErr_Occurred()) SWIG_fail;
39031 }
39032 resultobj = result;
39033 return resultobj;
39034 fail:
39035 return NULL;
39036 }
39037
39038
39039 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39040 PyObject *resultobj = 0;
39041 wxValidator *result = 0 ;
39042
39043 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
39044 {
39045 PyThreadState* __tstate = wxPyBeginAllowThreads();
39046 result = (wxValidator *)new wxValidator();
39047 wxPyEndAllowThreads(__tstate);
39048 if (PyErr_Occurred()) SWIG_fail;
39049 }
39050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
39051 return resultobj;
39052 fail:
39053 return NULL;
39054 }
39055
39056
39057 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39058 PyObject *resultobj = 0;
39059 wxValidator *arg1 = (wxValidator *) 0 ;
39060 wxValidator *result = 0 ;
39061 void *argp1 = 0 ;
39062 int res1 = 0 ;
39063 PyObject *swig_obj[1] ;
39064
39065 if (!args) SWIG_fail;
39066 swig_obj[0] = args;
39067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39068 if (!SWIG_IsOK(res1)) {
39069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
39070 }
39071 arg1 = reinterpret_cast< wxValidator * >(argp1);
39072 {
39073 PyThreadState* __tstate = wxPyBeginAllowThreads();
39074 result = (wxValidator *)(arg1)->Clone();
39075 wxPyEndAllowThreads(__tstate);
39076 if (PyErr_Occurred()) SWIG_fail;
39077 }
39078 {
39079 resultobj = wxPyMake_wxObject(result, 0);
39080 }
39081 return resultobj;
39082 fail:
39083 return NULL;
39084 }
39085
39086
39087 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39088 PyObject *resultobj = 0;
39089 wxValidator *arg1 = (wxValidator *) 0 ;
39090 wxWindow *arg2 = (wxWindow *) 0 ;
39091 bool result;
39092 void *argp1 = 0 ;
39093 int res1 = 0 ;
39094 void *argp2 = 0 ;
39095 int res2 = 0 ;
39096 PyObject * obj0 = 0 ;
39097 PyObject * obj1 = 0 ;
39098 char * kwnames[] = {
39099 (char *) "self",(char *) "parent", NULL
39100 };
39101
39102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
39103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39104 if (!SWIG_IsOK(res1)) {
39105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
39106 }
39107 arg1 = reinterpret_cast< wxValidator * >(argp1);
39108 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39109 if (!SWIG_IsOK(res2)) {
39110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
39111 }
39112 arg2 = reinterpret_cast< wxWindow * >(argp2);
39113 {
39114 PyThreadState* __tstate = wxPyBeginAllowThreads();
39115 result = (bool)(arg1)->Validate(arg2);
39116 wxPyEndAllowThreads(__tstate);
39117 if (PyErr_Occurred()) SWIG_fail;
39118 }
39119 {
39120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39121 }
39122 return resultobj;
39123 fail:
39124 return NULL;
39125 }
39126
39127
39128 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39129 PyObject *resultobj = 0;
39130 wxValidator *arg1 = (wxValidator *) 0 ;
39131 bool result;
39132 void *argp1 = 0 ;
39133 int res1 = 0 ;
39134 PyObject *swig_obj[1] ;
39135
39136 if (!args) SWIG_fail;
39137 swig_obj[0] = args;
39138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39139 if (!SWIG_IsOK(res1)) {
39140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39141 }
39142 arg1 = reinterpret_cast< wxValidator * >(argp1);
39143 {
39144 PyThreadState* __tstate = wxPyBeginAllowThreads();
39145 result = (bool)(arg1)->TransferToWindow();
39146 wxPyEndAllowThreads(__tstate);
39147 if (PyErr_Occurred()) SWIG_fail;
39148 }
39149 {
39150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39151 }
39152 return resultobj;
39153 fail:
39154 return NULL;
39155 }
39156
39157
39158 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39159 PyObject *resultobj = 0;
39160 wxValidator *arg1 = (wxValidator *) 0 ;
39161 bool result;
39162 void *argp1 = 0 ;
39163 int res1 = 0 ;
39164 PyObject *swig_obj[1] ;
39165
39166 if (!args) SWIG_fail;
39167 swig_obj[0] = args;
39168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39169 if (!SWIG_IsOK(res1)) {
39170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39171 }
39172 arg1 = reinterpret_cast< wxValidator * >(argp1);
39173 {
39174 PyThreadState* __tstate = wxPyBeginAllowThreads();
39175 result = (bool)(arg1)->TransferFromWindow();
39176 wxPyEndAllowThreads(__tstate);
39177 if (PyErr_Occurred()) SWIG_fail;
39178 }
39179 {
39180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39181 }
39182 return resultobj;
39183 fail:
39184 return NULL;
39185 }
39186
39187
39188 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39189 PyObject *resultobj = 0;
39190 wxValidator *arg1 = (wxValidator *) 0 ;
39191 wxWindow *result = 0 ;
39192 void *argp1 = 0 ;
39193 int res1 = 0 ;
39194 PyObject *swig_obj[1] ;
39195
39196 if (!args) SWIG_fail;
39197 swig_obj[0] = args;
39198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39199 if (!SWIG_IsOK(res1)) {
39200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39201 }
39202 arg1 = reinterpret_cast< wxValidator * >(argp1);
39203 {
39204 PyThreadState* __tstate = wxPyBeginAllowThreads();
39205 result = (wxWindow *)(arg1)->GetWindow();
39206 wxPyEndAllowThreads(__tstate);
39207 if (PyErr_Occurred()) SWIG_fail;
39208 }
39209 {
39210 resultobj = wxPyMake_wxObject(result, 0);
39211 }
39212 return resultobj;
39213 fail:
39214 return NULL;
39215 }
39216
39217
39218 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39219 PyObject *resultobj = 0;
39220 wxValidator *arg1 = (wxValidator *) 0 ;
39221 wxWindow *arg2 = (wxWindow *) 0 ;
39222 void *argp1 = 0 ;
39223 int res1 = 0 ;
39224 void *argp2 = 0 ;
39225 int res2 = 0 ;
39226 PyObject * obj0 = 0 ;
39227 PyObject * obj1 = 0 ;
39228 char * kwnames[] = {
39229 (char *) "self",(char *) "window", NULL
39230 };
39231
39232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
39233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39234 if (!SWIG_IsOK(res1)) {
39235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39236 }
39237 arg1 = reinterpret_cast< wxValidator * >(argp1);
39238 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39239 if (!SWIG_IsOK(res2)) {
39240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
39241 }
39242 arg2 = reinterpret_cast< wxWindow * >(argp2);
39243 {
39244 PyThreadState* __tstate = wxPyBeginAllowThreads();
39245 (arg1)->SetWindow(arg2);
39246 wxPyEndAllowThreads(__tstate);
39247 if (PyErr_Occurred()) SWIG_fail;
39248 }
39249 resultobj = SWIG_Py_Void();
39250 return resultobj;
39251 fail:
39252 return NULL;
39253 }
39254
39255
39256 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39257 PyObject *resultobj = 0;
39258 bool result;
39259
39260 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
39261 {
39262 PyThreadState* __tstate = wxPyBeginAllowThreads();
39263 result = (bool)wxValidator::IsSilent();
39264 wxPyEndAllowThreads(__tstate);
39265 if (PyErr_Occurred()) SWIG_fail;
39266 }
39267 {
39268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39269 }
39270 return resultobj;
39271 fail:
39272 return NULL;
39273 }
39274
39275
39276 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39277 PyObject *resultobj = 0;
39278 int arg1 = (int) true ;
39279 int val1 ;
39280 int ecode1 = 0 ;
39281 PyObject * obj0 = 0 ;
39282 char * kwnames[] = {
39283 (char *) "doIt", NULL
39284 };
39285
39286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
39287 if (obj0) {
39288 ecode1 = SWIG_AsVal_int(obj0, &val1);
39289 if (!SWIG_IsOK(ecode1)) {
39290 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
39291 }
39292 arg1 = static_cast< int >(val1);
39293 }
39294 {
39295 PyThreadState* __tstate = wxPyBeginAllowThreads();
39296 wxValidator::SetBellOnError(arg1);
39297 wxPyEndAllowThreads(__tstate);
39298 if (PyErr_Occurred()) SWIG_fail;
39299 }
39300 resultobj = SWIG_Py_Void();
39301 return resultobj;
39302 fail:
39303 return NULL;
39304 }
39305
39306
39307 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39308 PyObject *obj;
39309 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39310 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
39311 return SWIG_Py_Void();
39312 }
39313
39314 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39315 return SWIG_Python_InitShadowInstance(args);
39316 }
39317
39318 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39319 PyObject *resultobj = 0;
39320 wxPyValidator *result = 0 ;
39321
39322 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
39323 {
39324 PyThreadState* __tstate = wxPyBeginAllowThreads();
39325 result = (wxPyValidator *)new wxPyValidator();
39326 wxPyEndAllowThreads(__tstate);
39327 if (PyErr_Occurred()) SWIG_fail;
39328 }
39329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
39330 return resultobj;
39331 fail:
39332 return NULL;
39333 }
39334
39335
39336 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39337 PyObject *resultobj = 0;
39338 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
39339 PyObject *arg2 = (PyObject *) 0 ;
39340 PyObject *arg3 = (PyObject *) 0 ;
39341 int arg4 = (int) true ;
39342 void *argp1 = 0 ;
39343 int res1 = 0 ;
39344 int val4 ;
39345 int ecode4 = 0 ;
39346 PyObject * obj0 = 0 ;
39347 PyObject * obj1 = 0 ;
39348 PyObject * obj2 = 0 ;
39349 PyObject * obj3 = 0 ;
39350 char * kwnames[] = {
39351 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
39352 };
39353
39354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
39356 if (!SWIG_IsOK(res1)) {
39357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
39358 }
39359 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
39360 arg2 = obj1;
39361 arg3 = obj2;
39362 if (obj3) {
39363 ecode4 = SWIG_AsVal_int(obj3, &val4);
39364 if (!SWIG_IsOK(ecode4)) {
39365 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
39366 }
39367 arg4 = static_cast< int >(val4);
39368 }
39369 {
39370 PyThreadState* __tstate = wxPyBeginAllowThreads();
39371 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
39372 wxPyEndAllowThreads(__tstate);
39373 if (PyErr_Occurred()) SWIG_fail;
39374 }
39375 resultobj = SWIG_Py_Void();
39376 return resultobj;
39377 fail:
39378 return NULL;
39379 }
39380
39381
39382 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39383 PyObject *obj;
39384 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39385 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
39386 return SWIG_Py_Void();
39387 }
39388
39389 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39390 return SWIG_Python_InitShadowInstance(args);
39391 }
39392
39393 SWIGINTERN int DefaultValidator_set(PyObject *) {
39394 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
39395 return 1;
39396 }
39397
39398
39399 SWIGINTERN PyObject *DefaultValidator_get(void) {
39400 PyObject *pyobj = 0;
39401
39402 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
39403 return pyobj;
39404 }
39405
39406
39407 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39408 PyObject *resultobj = 0;
39409 wxString const &arg1_defvalue = wxPyEmptyString ;
39410 wxString *arg1 = (wxString *) &arg1_defvalue ;
39411 long arg2 = (long) 0 ;
39412 wxMenu *result = 0 ;
39413 bool temp1 = false ;
39414 long val2 ;
39415 int ecode2 = 0 ;
39416 PyObject * obj0 = 0 ;
39417 PyObject * obj1 = 0 ;
39418 char * kwnames[] = {
39419 (char *) "title",(char *) "style", NULL
39420 };
39421
39422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
39423 if (obj0) {
39424 {
39425 arg1 = wxString_in_helper(obj0);
39426 if (arg1 == NULL) SWIG_fail;
39427 temp1 = true;
39428 }
39429 }
39430 if (obj1) {
39431 ecode2 = SWIG_AsVal_long(obj1, &val2);
39432 if (!SWIG_IsOK(ecode2)) {
39433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
39434 }
39435 arg2 = static_cast< long >(val2);
39436 }
39437 {
39438 if (!wxPyCheckForApp()) SWIG_fail;
39439 PyThreadState* __tstate = wxPyBeginAllowThreads();
39440 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
39441 wxPyEndAllowThreads(__tstate);
39442 if (PyErr_Occurred()) SWIG_fail;
39443 }
39444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
39445 {
39446 if (temp1)
39447 delete arg1;
39448 }
39449 return resultobj;
39450 fail:
39451 {
39452 if (temp1)
39453 delete arg1;
39454 }
39455 return NULL;
39456 }
39457
39458
39459 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39460 PyObject *resultobj = 0;
39461 wxMenu *arg1 = (wxMenu *) 0 ;
39462 int arg2 ;
39463 wxString const &arg3_defvalue = wxPyEmptyString ;
39464 wxString *arg3 = (wxString *) &arg3_defvalue ;
39465 wxString const &arg4_defvalue = wxPyEmptyString ;
39466 wxString *arg4 = (wxString *) &arg4_defvalue ;
39467 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39468 wxMenuItem *result = 0 ;
39469 void *argp1 = 0 ;
39470 int res1 = 0 ;
39471 int val2 ;
39472 int ecode2 = 0 ;
39473 bool temp3 = false ;
39474 bool temp4 = false ;
39475 int val5 ;
39476 int ecode5 = 0 ;
39477 PyObject * obj0 = 0 ;
39478 PyObject * obj1 = 0 ;
39479 PyObject * obj2 = 0 ;
39480 PyObject * obj3 = 0 ;
39481 PyObject * obj4 = 0 ;
39482 char * kwnames[] = {
39483 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39484 };
39485
39486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39488 if (!SWIG_IsOK(res1)) {
39489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39490 }
39491 arg1 = reinterpret_cast< wxMenu * >(argp1);
39492 ecode2 = SWIG_AsVal_int(obj1, &val2);
39493 if (!SWIG_IsOK(ecode2)) {
39494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39495 }
39496 arg2 = static_cast< int >(val2);
39497 if (obj2) {
39498 {
39499 arg3 = wxString_in_helper(obj2);
39500 if (arg3 == NULL) SWIG_fail;
39501 temp3 = true;
39502 }
39503 }
39504 if (obj3) {
39505 {
39506 arg4 = wxString_in_helper(obj3);
39507 if (arg4 == NULL) SWIG_fail;
39508 temp4 = true;
39509 }
39510 }
39511 if (obj4) {
39512 ecode5 = SWIG_AsVal_int(obj4, &val5);
39513 if (!SWIG_IsOK(ecode5)) {
39514 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39515 }
39516 arg5 = static_cast< wxItemKind >(val5);
39517 }
39518 {
39519 PyThreadState* __tstate = wxPyBeginAllowThreads();
39520 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39521 wxPyEndAllowThreads(__tstate);
39522 if (PyErr_Occurred()) SWIG_fail;
39523 }
39524 {
39525 resultobj = wxPyMake_wxObject(result, (bool)0);
39526 }
39527 {
39528 if (temp3)
39529 delete arg3;
39530 }
39531 {
39532 if (temp4)
39533 delete arg4;
39534 }
39535 return resultobj;
39536 fail:
39537 {
39538 if (temp3)
39539 delete arg3;
39540 }
39541 {
39542 if (temp4)
39543 delete arg4;
39544 }
39545 return NULL;
39546 }
39547
39548
39549 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39550 PyObject *resultobj = 0;
39551 wxMenu *arg1 = (wxMenu *) 0 ;
39552 wxMenuItem *result = 0 ;
39553 void *argp1 = 0 ;
39554 int res1 = 0 ;
39555 PyObject *swig_obj[1] ;
39556
39557 if (!args) SWIG_fail;
39558 swig_obj[0] = args;
39559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39560 if (!SWIG_IsOK(res1)) {
39561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39562 }
39563 arg1 = reinterpret_cast< wxMenu * >(argp1);
39564 {
39565 PyThreadState* __tstate = wxPyBeginAllowThreads();
39566 result = (wxMenuItem *)(arg1)->AppendSeparator();
39567 wxPyEndAllowThreads(__tstate);
39568 if (PyErr_Occurred()) SWIG_fail;
39569 }
39570 {
39571 resultobj = wxPyMake_wxObject(result, (bool)0);
39572 }
39573 return resultobj;
39574 fail:
39575 return NULL;
39576 }
39577
39578
39579 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39580 PyObject *resultobj = 0;
39581 wxMenu *arg1 = (wxMenu *) 0 ;
39582 int arg2 ;
39583 wxString *arg3 = 0 ;
39584 wxString const &arg4_defvalue = wxPyEmptyString ;
39585 wxString *arg4 = (wxString *) &arg4_defvalue ;
39586 wxMenuItem *result = 0 ;
39587 void *argp1 = 0 ;
39588 int res1 = 0 ;
39589 int val2 ;
39590 int ecode2 = 0 ;
39591 bool temp3 = false ;
39592 bool temp4 = false ;
39593 PyObject * obj0 = 0 ;
39594 PyObject * obj1 = 0 ;
39595 PyObject * obj2 = 0 ;
39596 PyObject * obj3 = 0 ;
39597 char * kwnames[] = {
39598 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39599 };
39600
39601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39603 if (!SWIG_IsOK(res1)) {
39604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39605 }
39606 arg1 = reinterpret_cast< wxMenu * >(argp1);
39607 ecode2 = SWIG_AsVal_int(obj1, &val2);
39608 if (!SWIG_IsOK(ecode2)) {
39609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39610 }
39611 arg2 = static_cast< int >(val2);
39612 {
39613 arg3 = wxString_in_helper(obj2);
39614 if (arg3 == NULL) SWIG_fail;
39615 temp3 = true;
39616 }
39617 if (obj3) {
39618 {
39619 arg4 = wxString_in_helper(obj3);
39620 if (arg4 == NULL) SWIG_fail;
39621 temp4 = true;
39622 }
39623 }
39624 {
39625 PyThreadState* __tstate = wxPyBeginAllowThreads();
39626 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39627 wxPyEndAllowThreads(__tstate);
39628 if (PyErr_Occurred()) SWIG_fail;
39629 }
39630 {
39631 resultobj = wxPyMake_wxObject(result, (bool)0);
39632 }
39633 {
39634 if (temp3)
39635 delete arg3;
39636 }
39637 {
39638 if (temp4)
39639 delete arg4;
39640 }
39641 return resultobj;
39642 fail:
39643 {
39644 if (temp3)
39645 delete arg3;
39646 }
39647 {
39648 if (temp4)
39649 delete arg4;
39650 }
39651 return NULL;
39652 }
39653
39654
39655 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39656 PyObject *resultobj = 0;
39657 wxMenu *arg1 = (wxMenu *) 0 ;
39658 int arg2 ;
39659 wxString *arg3 = 0 ;
39660 wxString const &arg4_defvalue = wxPyEmptyString ;
39661 wxString *arg4 = (wxString *) &arg4_defvalue ;
39662 wxMenuItem *result = 0 ;
39663 void *argp1 = 0 ;
39664 int res1 = 0 ;
39665 int val2 ;
39666 int ecode2 = 0 ;
39667 bool temp3 = false ;
39668 bool temp4 = false ;
39669 PyObject * obj0 = 0 ;
39670 PyObject * obj1 = 0 ;
39671 PyObject * obj2 = 0 ;
39672 PyObject * obj3 = 0 ;
39673 char * kwnames[] = {
39674 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39675 };
39676
39677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39679 if (!SWIG_IsOK(res1)) {
39680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39681 }
39682 arg1 = reinterpret_cast< wxMenu * >(argp1);
39683 ecode2 = SWIG_AsVal_int(obj1, &val2);
39684 if (!SWIG_IsOK(ecode2)) {
39685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39686 }
39687 arg2 = static_cast< int >(val2);
39688 {
39689 arg3 = wxString_in_helper(obj2);
39690 if (arg3 == NULL) SWIG_fail;
39691 temp3 = true;
39692 }
39693 if (obj3) {
39694 {
39695 arg4 = wxString_in_helper(obj3);
39696 if (arg4 == NULL) SWIG_fail;
39697 temp4 = true;
39698 }
39699 }
39700 {
39701 PyThreadState* __tstate = wxPyBeginAllowThreads();
39702 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39703 wxPyEndAllowThreads(__tstate);
39704 if (PyErr_Occurred()) SWIG_fail;
39705 }
39706 {
39707 resultobj = wxPyMake_wxObject(result, (bool)0);
39708 }
39709 {
39710 if (temp3)
39711 delete arg3;
39712 }
39713 {
39714 if (temp4)
39715 delete arg4;
39716 }
39717 return resultobj;
39718 fail:
39719 {
39720 if (temp3)
39721 delete arg3;
39722 }
39723 {
39724 if (temp4)
39725 delete arg4;
39726 }
39727 return NULL;
39728 }
39729
39730
39731 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39732 PyObject *resultobj = 0;
39733 wxMenu *arg1 = (wxMenu *) 0 ;
39734 int arg2 ;
39735 wxString *arg3 = 0 ;
39736 wxMenu *arg4 = (wxMenu *) 0 ;
39737 wxString const &arg5_defvalue = wxPyEmptyString ;
39738 wxString *arg5 = (wxString *) &arg5_defvalue ;
39739 wxMenuItem *result = 0 ;
39740 void *argp1 = 0 ;
39741 int res1 = 0 ;
39742 int val2 ;
39743 int ecode2 = 0 ;
39744 bool temp3 = false ;
39745 void *argp4 = 0 ;
39746 int res4 = 0 ;
39747 bool temp5 = false ;
39748 PyObject * obj0 = 0 ;
39749 PyObject * obj1 = 0 ;
39750 PyObject * obj2 = 0 ;
39751 PyObject * obj3 = 0 ;
39752 PyObject * obj4 = 0 ;
39753 char * kwnames[] = {
39754 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39755 };
39756
39757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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_AppendMenu" "', 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_AppendMenu" "', 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 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39774 if (!SWIG_IsOK(res4)) {
39775 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39776 }
39777 arg4 = reinterpret_cast< wxMenu * >(argp4);
39778 if (obj4) {
39779 {
39780 arg5 = wxString_in_helper(obj4);
39781 if (arg5 == NULL) SWIG_fail;
39782 temp5 = true;
39783 }
39784 }
39785 {
39786 PyThreadState* __tstate = wxPyBeginAllowThreads();
39787 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39788 wxPyEndAllowThreads(__tstate);
39789 if (PyErr_Occurred()) SWIG_fail;
39790 }
39791 {
39792 resultobj = wxPyMake_wxObject(result, (bool)0);
39793 }
39794 {
39795 if (temp3)
39796 delete arg3;
39797 }
39798 {
39799 if (temp5)
39800 delete arg5;
39801 }
39802 return resultobj;
39803 fail:
39804 {
39805 if (temp3)
39806 delete arg3;
39807 }
39808 {
39809 if (temp5)
39810 delete arg5;
39811 }
39812 return NULL;
39813 }
39814
39815
39816 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39817 PyObject *resultobj = 0;
39818 wxMenu *arg1 = (wxMenu *) 0 ;
39819 wxMenu *arg2 = (wxMenu *) 0 ;
39820 wxString *arg3 = 0 ;
39821 wxString const &arg4_defvalue = wxPyEmptyString ;
39822 wxString *arg4 = (wxString *) &arg4_defvalue ;
39823 wxMenuItem *result = 0 ;
39824 void *argp1 = 0 ;
39825 int res1 = 0 ;
39826 void *argp2 = 0 ;
39827 int res2 = 0 ;
39828 bool temp3 = false ;
39829 bool temp4 = false ;
39830 PyObject * obj0 = 0 ;
39831 PyObject * obj1 = 0 ;
39832 PyObject * obj2 = 0 ;
39833 PyObject * obj3 = 0 ;
39834 char * kwnames[] = {
39835 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39836 };
39837
39838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39840 if (!SWIG_IsOK(res1)) {
39841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39842 }
39843 arg1 = reinterpret_cast< wxMenu * >(argp1);
39844 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39845 if (!SWIG_IsOK(res2)) {
39846 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39847 }
39848 arg2 = reinterpret_cast< wxMenu * >(argp2);
39849 {
39850 arg3 = wxString_in_helper(obj2);
39851 if (arg3 == NULL) SWIG_fail;
39852 temp3 = true;
39853 }
39854 if (obj3) {
39855 {
39856 arg4 = wxString_in_helper(obj3);
39857 if (arg4 == NULL) SWIG_fail;
39858 temp4 = true;
39859 }
39860 }
39861 {
39862 PyThreadState* __tstate = wxPyBeginAllowThreads();
39863 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39864 wxPyEndAllowThreads(__tstate);
39865 if (PyErr_Occurred()) SWIG_fail;
39866 }
39867 {
39868 resultobj = wxPyMake_wxObject(result, (bool)0);
39869 }
39870 {
39871 if (temp3)
39872 delete arg3;
39873 }
39874 {
39875 if (temp4)
39876 delete arg4;
39877 }
39878 return resultobj;
39879 fail:
39880 {
39881 if (temp3)
39882 delete arg3;
39883 }
39884 {
39885 if (temp4)
39886 delete arg4;
39887 }
39888 return NULL;
39889 }
39890
39891
39892 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39893 PyObject *resultobj = 0;
39894 wxMenu *arg1 = (wxMenu *) 0 ;
39895 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39896 wxMenuItem *result = 0 ;
39897 void *argp1 = 0 ;
39898 int res1 = 0 ;
39899 int res2 = 0 ;
39900 PyObject * obj0 = 0 ;
39901 PyObject * obj1 = 0 ;
39902 char * kwnames[] = {
39903 (char *) "self",(char *) "item", NULL
39904 };
39905
39906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39908 if (!SWIG_IsOK(res1)) {
39909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39910 }
39911 arg1 = reinterpret_cast< wxMenu * >(argp1);
39912 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39913 if (!SWIG_IsOK(res2)) {
39914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39915 }
39916 {
39917 PyThreadState* __tstate = wxPyBeginAllowThreads();
39918 result = (wxMenuItem *)(arg1)->Append(arg2);
39919 wxPyEndAllowThreads(__tstate);
39920 if (PyErr_Occurred()) SWIG_fail;
39921 }
39922 {
39923 resultobj = wxPyMake_wxObject(result, (bool)0);
39924 }
39925 return resultobj;
39926 fail:
39927 return NULL;
39928 }
39929
39930
39931 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39932 PyObject *resultobj = 0;
39933 wxMenu *arg1 = (wxMenu *) 0 ;
39934 size_t arg2 ;
39935 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39936 wxMenuItem *result = 0 ;
39937 void *argp1 = 0 ;
39938 int res1 = 0 ;
39939 size_t val2 ;
39940 int ecode2 = 0 ;
39941 int res3 = 0 ;
39942 PyObject * obj0 = 0 ;
39943 PyObject * obj1 = 0 ;
39944 PyObject * obj2 = 0 ;
39945 char * kwnames[] = {
39946 (char *) "self",(char *) "pos",(char *) "item", NULL
39947 };
39948
39949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39951 if (!SWIG_IsOK(res1)) {
39952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39953 }
39954 arg1 = reinterpret_cast< wxMenu * >(argp1);
39955 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39956 if (!SWIG_IsOK(ecode2)) {
39957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39958 }
39959 arg2 = static_cast< size_t >(val2);
39960 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39961 if (!SWIG_IsOK(res3)) {
39962 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39963 }
39964 {
39965 PyThreadState* __tstate = wxPyBeginAllowThreads();
39966 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39967 wxPyEndAllowThreads(__tstate);
39968 if (PyErr_Occurred()) SWIG_fail;
39969 }
39970 {
39971 resultobj = wxPyMake_wxObject(result, (bool)0);
39972 }
39973 return resultobj;
39974 fail:
39975 return NULL;
39976 }
39977
39978
39979 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39980 PyObject *resultobj = 0;
39981 wxMenu *arg1 = (wxMenu *) 0 ;
39982 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39983 wxMenuItem *result = 0 ;
39984 void *argp1 = 0 ;
39985 int res1 = 0 ;
39986 int res2 = 0 ;
39987 PyObject * obj0 = 0 ;
39988 PyObject * obj1 = 0 ;
39989 char * kwnames[] = {
39990 (char *) "self",(char *) "item", NULL
39991 };
39992
39993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39995 if (!SWIG_IsOK(res1)) {
39996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39997 }
39998 arg1 = reinterpret_cast< wxMenu * >(argp1);
39999 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40000 if (!SWIG_IsOK(res2)) {
40001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40002 }
40003 {
40004 PyThreadState* __tstate = wxPyBeginAllowThreads();
40005 result = (wxMenuItem *)(arg1)->Prepend(arg2);
40006 wxPyEndAllowThreads(__tstate);
40007 if (PyErr_Occurred()) SWIG_fail;
40008 }
40009 {
40010 resultobj = wxPyMake_wxObject(result, (bool)0);
40011 }
40012 return resultobj;
40013 fail:
40014 return NULL;
40015 }
40016
40017
40018 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40019 PyObject *resultobj = 0;
40020 wxMenu *arg1 = (wxMenu *) 0 ;
40021 void *argp1 = 0 ;
40022 int res1 = 0 ;
40023 PyObject *swig_obj[1] ;
40024
40025 if (!args) SWIG_fail;
40026 swig_obj[0] = args;
40027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40028 if (!SWIG_IsOK(res1)) {
40029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
40030 }
40031 arg1 = reinterpret_cast< wxMenu * >(argp1);
40032 {
40033 PyThreadState* __tstate = wxPyBeginAllowThreads();
40034 (arg1)->Break();
40035 wxPyEndAllowThreads(__tstate);
40036 if (PyErr_Occurred()) SWIG_fail;
40037 }
40038 resultobj = SWIG_Py_Void();
40039 return resultobj;
40040 fail:
40041 return NULL;
40042 }
40043
40044
40045 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40046 PyObject *resultobj = 0;
40047 wxMenu *arg1 = (wxMenu *) 0 ;
40048 size_t arg2 ;
40049 int arg3 ;
40050 wxString const &arg4_defvalue = wxPyEmptyString ;
40051 wxString *arg4 = (wxString *) &arg4_defvalue ;
40052 wxString const &arg5_defvalue = wxPyEmptyString ;
40053 wxString *arg5 = (wxString *) &arg5_defvalue ;
40054 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
40055 wxMenuItem *result = 0 ;
40056 void *argp1 = 0 ;
40057 int res1 = 0 ;
40058 size_t val2 ;
40059 int ecode2 = 0 ;
40060 int val3 ;
40061 int ecode3 = 0 ;
40062 bool temp4 = false ;
40063 bool temp5 = false ;
40064 int val6 ;
40065 int ecode6 = 0 ;
40066 PyObject * obj0 = 0 ;
40067 PyObject * obj1 = 0 ;
40068 PyObject * obj2 = 0 ;
40069 PyObject * obj3 = 0 ;
40070 PyObject * obj4 = 0 ;
40071 PyObject * obj5 = 0 ;
40072 char * kwnames[] = {
40073 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40074 };
40075
40076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40078 if (!SWIG_IsOK(res1)) {
40079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
40080 }
40081 arg1 = reinterpret_cast< wxMenu * >(argp1);
40082 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40083 if (!SWIG_IsOK(ecode2)) {
40084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
40085 }
40086 arg2 = static_cast< size_t >(val2);
40087 ecode3 = SWIG_AsVal_int(obj2, &val3);
40088 if (!SWIG_IsOK(ecode3)) {
40089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
40090 }
40091 arg3 = static_cast< int >(val3);
40092 if (obj3) {
40093 {
40094 arg4 = wxString_in_helper(obj3);
40095 if (arg4 == NULL) SWIG_fail;
40096 temp4 = true;
40097 }
40098 }
40099 if (obj4) {
40100 {
40101 arg5 = wxString_in_helper(obj4);
40102 if (arg5 == NULL) SWIG_fail;
40103 temp5 = true;
40104 }
40105 }
40106 if (obj5) {
40107 ecode6 = SWIG_AsVal_int(obj5, &val6);
40108 if (!SWIG_IsOK(ecode6)) {
40109 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
40110 }
40111 arg6 = static_cast< wxItemKind >(val6);
40112 }
40113 {
40114 PyThreadState* __tstate = wxPyBeginAllowThreads();
40115 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
40116 wxPyEndAllowThreads(__tstate);
40117 if (PyErr_Occurred()) SWIG_fail;
40118 }
40119 {
40120 resultobj = wxPyMake_wxObject(result, (bool)0);
40121 }
40122 {
40123 if (temp4)
40124 delete arg4;
40125 }
40126 {
40127 if (temp5)
40128 delete arg5;
40129 }
40130 return resultobj;
40131 fail:
40132 {
40133 if (temp4)
40134 delete arg4;
40135 }
40136 {
40137 if (temp5)
40138 delete arg5;
40139 }
40140 return NULL;
40141 }
40142
40143
40144 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40145 PyObject *resultobj = 0;
40146 wxMenu *arg1 = (wxMenu *) 0 ;
40147 size_t arg2 ;
40148 wxMenuItem *result = 0 ;
40149 void *argp1 = 0 ;
40150 int res1 = 0 ;
40151 size_t val2 ;
40152 int ecode2 = 0 ;
40153 PyObject * obj0 = 0 ;
40154 PyObject * obj1 = 0 ;
40155 char * kwnames[] = {
40156 (char *) "self",(char *) "pos", NULL
40157 };
40158
40159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
40160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40161 if (!SWIG_IsOK(res1)) {
40162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40163 }
40164 arg1 = reinterpret_cast< wxMenu * >(argp1);
40165 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40166 if (!SWIG_IsOK(ecode2)) {
40167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
40168 }
40169 arg2 = static_cast< size_t >(val2);
40170 {
40171 PyThreadState* __tstate = wxPyBeginAllowThreads();
40172 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
40173 wxPyEndAllowThreads(__tstate);
40174 if (PyErr_Occurred()) SWIG_fail;
40175 }
40176 {
40177 resultobj = wxPyMake_wxObject(result, (bool)0);
40178 }
40179 return resultobj;
40180 fail:
40181 return NULL;
40182 }
40183
40184
40185 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40186 PyObject *resultobj = 0;
40187 wxMenu *arg1 = (wxMenu *) 0 ;
40188 size_t arg2 ;
40189 int arg3 ;
40190 wxString *arg4 = 0 ;
40191 wxString const &arg5_defvalue = wxPyEmptyString ;
40192 wxString *arg5 = (wxString *) &arg5_defvalue ;
40193 wxMenuItem *result = 0 ;
40194 void *argp1 = 0 ;
40195 int res1 = 0 ;
40196 size_t val2 ;
40197 int ecode2 = 0 ;
40198 int val3 ;
40199 int ecode3 = 0 ;
40200 bool temp4 = false ;
40201 bool temp5 = false ;
40202 PyObject * obj0 = 0 ;
40203 PyObject * obj1 = 0 ;
40204 PyObject * obj2 = 0 ;
40205 PyObject * obj3 = 0 ;
40206 PyObject * obj4 = 0 ;
40207 char * kwnames[] = {
40208 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40209 };
40210
40211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40213 if (!SWIG_IsOK(res1)) {
40214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40215 }
40216 arg1 = reinterpret_cast< wxMenu * >(argp1);
40217 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40218 if (!SWIG_IsOK(ecode2)) {
40219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
40220 }
40221 arg2 = static_cast< size_t >(val2);
40222 ecode3 = SWIG_AsVal_int(obj2, &val3);
40223 if (!SWIG_IsOK(ecode3)) {
40224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
40225 }
40226 arg3 = static_cast< int >(val3);
40227 {
40228 arg4 = wxString_in_helper(obj3);
40229 if (arg4 == NULL) SWIG_fail;
40230 temp4 = true;
40231 }
40232 if (obj4) {
40233 {
40234 arg5 = wxString_in_helper(obj4);
40235 if (arg5 == NULL) SWIG_fail;
40236 temp5 = true;
40237 }
40238 }
40239 {
40240 PyThreadState* __tstate = wxPyBeginAllowThreads();
40241 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40242 wxPyEndAllowThreads(__tstate);
40243 if (PyErr_Occurred()) SWIG_fail;
40244 }
40245 {
40246 resultobj = wxPyMake_wxObject(result, (bool)0);
40247 }
40248 {
40249 if (temp4)
40250 delete arg4;
40251 }
40252 {
40253 if (temp5)
40254 delete arg5;
40255 }
40256 return resultobj;
40257 fail:
40258 {
40259 if (temp4)
40260 delete arg4;
40261 }
40262 {
40263 if (temp5)
40264 delete arg5;
40265 }
40266 return NULL;
40267 }
40268
40269
40270 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40271 PyObject *resultobj = 0;
40272 wxMenu *arg1 = (wxMenu *) 0 ;
40273 size_t arg2 ;
40274 int arg3 ;
40275 wxString *arg4 = 0 ;
40276 wxString const &arg5_defvalue = wxPyEmptyString ;
40277 wxString *arg5 = (wxString *) &arg5_defvalue ;
40278 wxMenuItem *result = 0 ;
40279 void *argp1 = 0 ;
40280 int res1 = 0 ;
40281 size_t val2 ;
40282 int ecode2 = 0 ;
40283 int val3 ;
40284 int ecode3 = 0 ;
40285 bool temp4 = false ;
40286 bool temp5 = false ;
40287 PyObject * obj0 = 0 ;
40288 PyObject * obj1 = 0 ;
40289 PyObject * obj2 = 0 ;
40290 PyObject * obj3 = 0 ;
40291 PyObject * obj4 = 0 ;
40292 char * kwnames[] = {
40293 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40294 };
40295
40296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40298 if (!SWIG_IsOK(res1)) {
40299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40300 }
40301 arg1 = reinterpret_cast< wxMenu * >(argp1);
40302 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40303 if (!SWIG_IsOK(ecode2)) {
40304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
40305 }
40306 arg2 = static_cast< size_t >(val2);
40307 ecode3 = SWIG_AsVal_int(obj2, &val3);
40308 if (!SWIG_IsOK(ecode3)) {
40309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
40310 }
40311 arg3 = static_cast< int >(val3);
40312 {
40313 arg4 = wxString_in_helper(obj3);
40314 if (arg4 == NULL) SWIG_fail;
40315 temp4 = true;
40316 }
40317 if (obj4) {
40318 {
40319 arg5 = wxString_in_helper(obj4);
40320 if (arg5 == NULL) SWIG_fail;
40321 temp5 = true;
40322 }
40323 }
40324 {
40325 PyThreadState* __tstate = wxPyBeginAllowThreads();
40326 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40327 wxPyEndAllowThreads(__tstate);
40328 if (PyErr_Occurred()) SWIG_fail;
40329 }
40330 {
40331 resultobj = wxPyMake_wxObject(result, (bool)0);
40332 }
40333 {
40334 if (temp4)
40335 delete arg4;
40336 }
40337 {
40338 if (temp5)
40339 delete arg5;
40340 }
40341 return resultobj;
40342 fail:
40343 {
40344 if (temp4)
40345 delete arg4;
40346 }
40347 {
40348 if (temp5)
40349 delete arg5;
40350 }
40351 return NULL;
40352 }
40353
40354
40355 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40356 PyObject *resultobj = 0;
40357 wxMenu *arg1 = (wxMenu *) 0 ;
40358 size_t arg2 ;
40359 int arg3 ;
40360 wxString *arg4 = 0 ;
40361 wxMenu *arg5 = (wxMenu *) 0 ;
40362 wxString const &arg6_defvalue = wxPyEmptyString ;
40363 wxString *arg6 = (wxString *) &arg6_defvalue ;
40364 wxMenuItem *result = 0 ;
40365 void *argp1 = 0 ;
40366 int res1 = 0 ;
40367 size_t val2 ;
40368 int ecode2 = 0 ;
40369 int val3 ;
40370 int ecode3 = 0 ;
40371 bool temp4 = false ;
40372 void *argp5 = 0 ;
40373 int res5 = 0 ;
40374 bool temp6 = false ;
40375 PyObject * obj0 = 0 ;
40376 PyObject * obj1 = 0 ;
40377 PyObject * obj2 = 0 ;
40378 PyObject * obj3 = 0 ;
40379 PyObject * obj4 = 0 ;
40380 PyObject * obj5 = 0 ;
40381 char * kwnames[] = {
40382 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40383 };
40384
40385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40387 if (!SWIG_IsOK(res1)) {
40388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40389 }
40390 arg1 = reinterpret_cast< wxMenu * >(argp1);
40391 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40392 if (!SWIG_IsOK(ecode2)) {
40393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
40394 }
40395 arg2 = static_cast< size_t >(val2);
40396 ecode3 = SWIG_AsVal_int(obj2, &val3);
40397 if (!SWIG_IsOK(ecode3)) {
40398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
40399 }
40400 arg3 = static_cast< int >(val3);
40401 {
40402 arg4 = wxString_in_helper(obj3);
40403 if (arg4 == NULL) SWIG_fail;
40404 temp4 = true;
40405 }
40406 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
40407 if (!SWIG_IsOK(res5)) {
40408 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
40409 }
40410 arg5 = reinterpret_cast< wxMenu * >(argp5);
40411 if (obj5) {
40412 {
40413 arg6 = wxString_in_helper(obj5);
40414 if (arg6 == NULL) SWIG_fail;
40415 temp6 = true;
40416 }
40417 }
40418 {
40419 PyThreadState* __tstate = wxPyBeginAllowThreads();
40420 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
40421 wxPyEndAllowThreads(__tstate);
40422 if (PyErr_Occurred()) SWIG_fail;
40423 }
40424 {
40425 resultobj = wxPyMake_wxObject(result, (bool)0);
40426 }
40427 {
40428 if (temp4)
40429 delete arg4;
40430 }
40431 {
40432 if (temp6)
40433 delete arg6;
40434 }
40435 return resultobj;
40436 fail:
40437 {
40438 if (temp4)
40439 delete arg4;
40440 }
40441 {
40442 if (temp6)
40443 delete arg6;
40444 }
40445 return NULL;
40446 }
40447
40448
40449 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40450 PyObject *resultobj = 0;
40451 wxMenu *arg1 = (wxMenu *) 0 ;
40452 int arg2 ;
40453 wxString const &arg3_defvalue = wxPyEmptyString ;
40454 wxString *arg3 = (wxString *) &arg3_defvalue ;
40455 wxString const &arg4_defvalue = wxPyEmptyString ;
40456 wxString *arg4 = (wxString *) &arg4_defvalue ;
40457 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40458 wxMenuItem *result = 0 ;
40459 void *argp1 = 0 ;
40460 int res1 = 0 ;
40461 int val2 ;
40462 int ecode2 = 0 ;
40463 bool temp3 = false ;
40464 bool temp4 = false ;
40465 int val5 ;
40466 int ecode5 = 0 ;
40467 PyObject * obj0 = 0 ;
40468 PyObject * obj1 = 0 ;
40469 PyObject * obj2 = 0 ;
40470 PyObject * obj3 = 0 ;
40471 PyObject * obj4 = 0 ;
40472 char * kwnames[] = {
40473 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40474 };
40475
40476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40478 if (!SWIG_IsOK(res1)) {
40479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40480 }
40481 arg1 = reinterpret_cast< wxMenu * >(argp1);
40482 ecode2 = SWIG_AsVal_int(obj1, &val2);
40483 if (!SWIG_IsOK(ecode2)) {
40484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40485 }
40486 arg2 = static_cast< int >(val2);
40487 if (obj2) {
40488 {
40489 arg3 = wxString_in_helper(obj2);
40490 if (arg3 == NULL) SWIG_fail;
40491 temp3 = true;
40492 }
40493 }
40494 if (obj3) {
40495 {
40496 arg4 = wxString_in_helper(obj3);
40497 if (arg4 == NULL) SWIG_fail;
40498 temp4 = true;
40499 }
40500 }
40501 if (obj4) {
40502 ecode5 = SWIG_AsVal_int(obj4, &val5);
40503 if (!SWIG_IsOK(ecode5)) {
40504 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40505 }
40506 arg5 = static_cast< wxItemKind >(val5);
40507 }
40508 {
40509 PyThreadState* __tstate = wxPyBeginAllowThreads();
40510 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40511 wxPyEndAllowThreads(__tstate);
40512 if (PyErr_Occurred()) SWIG_fail;
40513 }
40514 {
40515 resultobj = wxPyMake_wxObject(result, (bool)0);
40516 }
40517 {
40518 if (temp3)
40519 delete arg3;
40520 }
40521 {
40522 if (temp4)
40523 delete arg4;
40524 }
40525 return resultobj;
40526 fail:
40527 {
40528 if (temp3)
40529 delete arg3;
40530 }
40531 {
40532 if (temp4)
40533 delete arg4;
40534 }
40535 return NULL;
40536 }
40537
40538
40539 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40540 PyObject *resultobj = 0;
40541 wxMenu *arg1 = (wxMenu *) 0 ;
40542 wxMenuItem *result = 0 ;
40543 void *argp1 = 0 ;
40544 int res1 = 0 ;
40545 PyObject *swig_obj[1] ;
40546
40547 if (!args) SWIG_fail;
40548 swig_obj[0] = args;
40549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40550 if (!SWIG_IsOK(res1)) {
40551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40552 }
40553 arg1 = reinterpret_cast< wxMenu * >(argp1);
40554 {
40555 PyThreadState* __tstate = wxPyBeginAllowThreads();
40556 result = (wxMenuItem *)(arg1)->PrependSeparator();
40557 wxPyEndAllowThreads(__tstate);
40558 if (PyErr_Occurred()) SWIG_fail;
40559 }
40560 {
40561 resultobj = wxPyMake_wxObject(result, (bool)0);
40562 }
40563 return resultobj;
40564 fail:
40565 return NULL;
40566 }
40567
40568
40569 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40570 PyObject *resultobj = 0;
40571 wxMenu *arg1 = (wxMenu *) 0 ;
40572 int arg2 ;
40573 wxString *arg3 = 0 ;
40574 wxString const &arg4_defvalue = wxPyEmptyString ;
40575 wxString *arg4 = (wxString *) &arg4_defvalue ;
40576 wxMenuItem *result = 0 ;
40577 void *argp1 = 0 ;
40578 int res1 = 0 ;
40579 int val2 ;
40580 int ecode2 = 0 ;
40581 bool temp3 = false ;
40582 bool temp4 = false ;
40583 PyObject * obj0 = 0 ;
40584 PyObject * obj1 = 0 ;
40585 PyObject * obj2 = 0 ;
40586 PyObject * obj3 = 0 ;
40587 char * kwnames[] = {
40588 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40589 };
40590
40591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40593 if (!SWIG_IsOK(res1)) {
40594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40595 }
40596 arg1 = reinterpret_cast< wxMenu * >(argp1);
40597 ecode2 = SWIG_AsVal_int(obj1, &val2);
40598 if (!SWIG_IsOK(ecode2)) {
40599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40600 }
40601 arg2 = static_cast< int >(val2);
40602 {
40603 arg3 = wxString_in_helper(obj2);
40604 if (arg3 == NULL) SWIG_fail;
40605 temp3 = true;
40606 }
40607 if (obj3) {
40608 {
40609 arg4 = wxString_in_helper(obj3);
40610 if (arg4 == NULL) SWIG_fail;
40611 temp4 = true;
40612 }
40613 }
40614 {
40615 PyThreadState* __tstate = wxPyBeginAllowThreads();
40616 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40617 wxPyEndAllowThreads(__tstate);
40618 if (PyErr_Occurred()) SWIG_fail;
40619 }
40620 {
40621 resultobj = wxPyMake_wxObject(result, (bool)0);
40622 }
40623 {
40624 if (temp3)
40625 delete arg3;
40626 }
40627 {
40628 if (temp4)
40629 delete arg4;
40630 }
40631 return resultobj;
40632 fail:
40633 {
40634 if (temp3)
40635 delete arg3;
40636 }
40637 {
40638 if (temp4)
40639 delete arg4;
40640 }
40641 return NULL;
40642 }
40643
40644
40645 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40646 PyObject *resultobj = 0;
40647 wxMenu *arg1 = (wxMenu *) 0 ;
40648 int arg2 ;
40649 wxString *arg3 = 0 ;
40650 wxString const &arg4_defvalue = wxPyEmptyString ;
40651 wxString *arg4 = (wxString *) &arg4_defvalue ;
40652 wxMenuItem *result = 0 ;
40653 void *argp1 = 0 ;
40654 int res1 = 0 ;
40655 int val2 ;
40656 int ecode2 = 0 ;
40657 bool temp3 = false ;
40658 bool temp4 = false ;
40659 PyObject * obj0 = 0 ;
40660 PyObject * obj1 = 0 ;
40661 PyObject * obj2 = 0 ;
40662 PyObject * obj3 = 0 ;
40663 char * kwnames[] = {
40664 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40665 };
40666
40667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40669 if (!SWIG_IsOK(res1)) {
40670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40671 }
40672 arg1 = reinterpret_cast< wxMenu * >(argp1);
40673 ecode2 = SWIG_AsVal_int(obj1, &val2);
40674 if (!SWIG_IsOK(ecode2)) {
40675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40676 }
40677 arg2 = static_cast< int >(val2);
40678 {
40679 arg3 = wxString_in_helper(obj2);
40680 if (arg3 == NULL) SWIG_fail;
40681 temp3 = true;
40682 }
40683 if (obj3) {
40684 {
40685 arg4 = wxString_in_helper(obj3);
40686 if (arg4 == NULL) SWIG_fail;
40687 temp4 = true;
40688 }
40689 }
40690 {
40691 PyThreadState* __tstate = wxPyBeginAllowThreads();
40692 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40693 wxPyEndAllowThreads(__tstate);
40694 if (PyErr_Occurred()) SWIG_fail;
40695 }
40696 {
40697 resultobj = wxPyMake_wxObject(result, (bool)0);
40698 }
40699 {
40700 if (temp3)
40701 delete arg3;
40702 }
40703 {
40704 if (temp4)
40705 delete arg4;
40706 }
40707 return resultobj;
40708 fail:
40709 {
40710 if (temp3)
40711 delete arg3;
40712 }
40713 {
40714 if (temp4)
40715 delete arg4;
40716 }
40717 return NULL;
40718 }
40719
40720
40721 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40722 PyObject *resultobj = 0;
40723 wxMenu *arg1 = (wxMenu *) 0 ;
40724 int arg2 ;
40725 wxString *arg3 = 0 ;
40726 wxMenu *arg4 = (wxMenu *) 0 ;
40727 wxString const &arg5_defvalue = wxPyEmptyString ;
40728 wxString *arg5 = (wxString *) &arg5_defvalue ;
40729 wxMenuItem *result = 0 ;
40730 void *argp1 = 0 ;
40731 int res1 = 0 ;
40732 int val2 ;
40733 int ecode2 = 0 ;
40734 bool temp3 = false ;
40735 void *argp4 = 0 ;
40736 int res4 = 0 ;
40737 bool temp5 = false ;
40738 PyObject * obj0 = 0 ;
40739 PyObject * obj1 = 0 ;
40740 PyObject * obj2 = 0 ;
40741 PyObject * obj3 = 0 ;
40742 PyObject * obj4 = 0 ;
40743 char * kwnames[] = {
40744 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40745 };
40746
40747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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_PrependMenu" "', 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_PrependMenu" "', 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 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40764 if (!SWIG_IsOK(res4)) {
40765 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40766 }
40767 arg4 = reinterpret_cast< wxMenu * >(argp4);
40768 if (obj4) {
40769 {
40770 arg5 = wxString_in_helper(obj4);
40771 if (arg5 == NULL) SWIG_fail;
40772 temp5 = true;
40773 }
40774 }
40775 {
40776 PyThreadState* __tstate = wxPyBeginAllowThreads();
40777 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40778 wxPyEndAllowThreads(__tstate);
40779 if (PyErr_Occurred()) SWIG_fail;
40780 }
40781 {
40782 resultobj = wxPyMake_wxObject(result, (bool)0);
40783 }
40784 {
40785 if (temp3)
40786 delete arg3;
40787 }
40788 {
40789 if (temp5)
40790 delete arg5;
40791 }
40792 return resultobj;
40793 fail:
40794 {
40795 if (temp3)
40796 delete arg3;
40797 }
40798 {
40799 if (temp5)
40800 delete arg5;
40801 }
40802 return NULL;
40803 }
40804
40805
40806 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40807 PyObject *resultobj = 0;
40808 wxMenu *arg1 = (wxMenu *) 0 ;
40809 int arg2 ;
40810 wxMenuItem *result = 0 ;
40811 void *argp1 = 0 ;
40812 int res1 = 0 ;
40813 int val2 ;
40814 int ecode2 = 0 ;
40815 PyObject * obj0 = 0 ;
40816 PyObject * obj1 = 0 ;
40817 char * kwnames[] = {
40818 (char *) "self",(char *) "id", NULL
40819 };
40820
40821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40823 if (!SWIG_IsOK(res1)) {
40824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40825 }
40826 arg1 = reinterpret_cast< wxMenu * >(argp1);
40827 ecode2 = SWIG_AsVal_int(obj1, &val2);
40828 if (!SWIG_IsOK(ecode2)) {
40829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40830 }
40831 arg2 = static_cast< int >(val2);
40832 {
40833 PyThreadState* __tstate = wxPyBeginAllowThreads();
40834 result = (wxMenuItem *)(arg1)->Remove(arg2);
40835 wxPyEndAllowThreads(__tstate);
40836 if (PyErr_Occurred()) SWIG_fail;
40837 }
40838 {
40839 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40840 }
40841 return resultobj;
40842 fail:
40843 return NULL;
40844 }
40845
40846
40847 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40848 PyObject *resultobj = 0;
40849 wxMenu *arg1 = (wxMenu *) 0 ;
40850 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40851 wxMenuItem *result = 0 ;
40852 void *argp1 = 0 ;
40853 int res1 = 0 ;
40854 void *argp2 = 0 ;
40855 int res2 = 0 ;
40856 PyObject * obj0 = 0 ;
40857 PyObject * obj1 = 0 ;
40858 char * kwnames[] = {
40859 (char *) "self",(char *) "item", NULL
40860 };
40861
40862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40864 if (!SWIG_IsOK(res1)) {
40865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40866 }
40867 arg1 = reinterpret_cast< wxMenu * >(argp1);
40868 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40869 if (!SWIG_IsOK(res2)) {
40870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40871 }
40872 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40873 {
40874 PyThreadState* __tstate = wxPyBeginAllowThreads();
40875 result = (wxMenuItem *)(arg1)->Remove(arg2);
40876 wxPyEndAllowThreads(__tstate);
40877 if (PyErr_Occurred()) SWIG_fail;
40878 }
40879 {
40880 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40881 }
40882 return resultobj;
40883 fail:
40884 return NULL;
40885 }
40886
40887
40888 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40889 PyObject *resultobj = 0;
40890 wxMenu *arg1 = (wxMenu *) 0 ;
40891 int arg2 ;
40892 bool result;
40893 void *argp1 = 0 ;
40894 int res1 = 0 ;
40895 int val2 ;
40896 int ecode2 = 0 ;
40897 PyObject * obj0 = 0 ;
40898 PyObject * obj1 = 0 ;
40899 char * kwnames[] = {
40900 (char *) "self",(char *) "id", NULL
40901 };
40902
40903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) 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_Delete" "', 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_Delete" "', expected argument " "2"" of type '" "int""'");
40912 }
40913 arg2 = static_cast< int >(val2);
40914 {
40915 PyThreadState* __tstate = wxPyBeginAllowThreads();
40916 result = (bool)(arg1)->Delete(arg2);
40917 wxPyEndAllowThreads(__tstate);
40918 if (PyErr_Occurred()) SWIG_fail;
40919 }
40920 {
40921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40922 }
40923 return resultobj;
40924 fail:
40925 return NULL;
40926 }
40927
40928
40929 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40930 PyObject *resultobj = 0;
40931 wxMenu *arg1 = (wxMenu *) 0 ;
40932 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40933 bool result;
40934 void *argp1 = 0 ;
40935 int res1 = 0 ;
40936 void *argp2 = 0 ;
40937 int res2 = 0 ;
40938 PyObject * obj0 = 0 ;
40939 PyObject * obj1 = 0 ;
40940 char * kwnames[] = {
40941 (char *) "self",(char *) "item", NULL
40942 };
40943
40944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40946 if (!SWIG_IsOK(res1)) {
40947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40948 }
40949 arg1 = reinterpret_cast< wxMenu * >(argp1);
40950 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40951 if (!SWIG_IsOK(res2)) {
40952 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40953 }
40954 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40955 {
40956 PyThreadState* __tstate = wxPyBeginAllowThreads();
40957 result = (bool)(arg1)->Delete(arg2);
40958 wxPyEndAllowThreads(__tstate);
40959 if (PyErr_Occurred()) SWIG_fail;
40960 }
40961 {
40962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40963 }
40964 return resultobj;
40965 fail:
40966 return NULL;
40967 }
40968
40969
40970 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40971 PyObject *resultobj = 0;
40972 wxMenu *arg1 = (wxMenu *) 0 ;
40973 void *argp1 = 0 ;
40974 int res1 = 0 ;
40975 PyObject *swig_obj[1] ;
40976
40977 if (!args) SWIG_fail;
40978 swig_obj[0] = args;
40979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40980 if (!SWIG_IsOK(res1)) {
40981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40982 }
40983 arg1 = reinterpret_cast< wxMenu * >(argp1);
40984 {
40985 PyThreadState* __tstate = wxPyBeginAllowThreads();
40986 wxMenu_Destroy(arg1);
40987 wxPyEndAllowThreads(__tstate);
40988 if (PyErr_Occurred()) SWIG_fail;
40989 }
40990 resultobj = SWIG_Py_Void();
40991 return resultobj;
40992 fail:
40993 return NULL;
40994 }
40995
40996
40997 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40998 PyObject *resultobj = 0;
40999 wxMenu *arg1 = (wxMenu *) 0 ;
41000 int arg2 ;
41001 bool result;
41002 void *argp1 = 0 ;
41003 int res1 = 0 ;
41004 int val2 ;
41005 int ecode2 = 0 ;
41006 PyObject * obj0 = 0 ;
41007 PyObject * obj1 = 0 ;
41008 char * kwnames[] = {
41009 (char *) "self",(char *) "id", NULL
41010 };
41011
41012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
41013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41014 if (!SWIG_IsOK(res1)) {
41015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
41016 }
41017 arg1 = reinterpret_cast< wxMenu * >(argp1);
41018 ecode2 = SWIG_AsVal_int(obj1, &val2);
41019 if (!SWIG_IsOK(ecode2)) {
41020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
41021 }
41022 arg2 = static_cast< int >(val2);
41023 {
41024 PyThreadState* __tstate = wxPyBeginAllowThreads();
41025 result = (bool)(arg1)->Destroy(arg2);
41026 wxPyEndAllowThreads(__tstate);
41027 if (PyErr_Occurred()) SWIG_fail;
41028 }
41029 {
41030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41031 }
41032 return resultobj;
41033 fail:
41034 return NULL;
41035 }
41036
41037
41038 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41039 PyObject *resultobj = 0;
41040 wxMenu *arg1 = (wxMenu *) 0 ;
41041 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41042 bool result;
41043 void *argp1 = 0 ;
41044 int res1 = 0 ;
41045 void *argp2 = 0 ;
41046 int res2 = 0 ;
41047 PyObject * obj0 = 0 ;
41048 PyObject * obj1 = 0 ;
41049 char * kwnames[] = {
41050 (char *) "self",(char *) "item", NULL
41051 };
41052
41053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
41054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41055 if (!SWIG_IsOK(res1)) {
41056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41057 }
41058 arg1 = reinterpret_cast< wxMenu * >(argp1);
41059 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41060 if (!SWIG_IsOK(res2)) {
41061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41062 }
41063 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41064 {
41065 PyThreadState* __tstate = wxPyBeginAllowThreads();
41066 result = (bool)(arg1)->Destroy(arg2);
41067 wxPyEndAllowThreads(__tstate);
41068 if (PyErr_Occurred()) SWIG_fail;
41069 }
41070 {
41071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41072 }
41073 return resultobj;
41074 fail:
41075 return NULL;
41076 }
41077
41078
41079 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41080 PyObject *resultobj = 0;
41081 wxMenu *arg1 = (wxMenu *) 0 ;
41082 size_t result;
41083 void *argp1 = 0 ;
41084 int res1 = 0 ;
41085 PyObject *swig_obj[1] ;
41086
41087 if (!args) SWIG_fail;
41088 swig_obj[0] = args;
41089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41090 if (!SWIG_IsOK(res1)) {
41091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
41092 }
41093 arg1 = reinterpret_cast< wxMenu * >(argp1);
41094 {
41095 PyThreadState* __tstate = wxPyBeginAllowThreads();
41096 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
41097 wxPyEndAllowThreads(__tstate);
41098 if (PyErr_Occurred()) SWIG_fail;
41099 }
41100 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41101 return resultobj;
41102 fail:
41103 return NULL;
41104 }
41105
41106
41107 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41108 PyObject *resultobj = 0;
41109 wxMenu *arg1 = (wxMenu *) 0 ;
41110 PyObject *result = 0 ;
41111 void *argp1 = 0 ;
41112 int res1 = 0 ;
41113 PyObject *swig_obj[1] ;
41114
41115 if (!args) SWIG_fail;
41116 swig_obj[0] = args;
41117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41118 if (!SWIG_IsOK(res1)) {
41119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
41120 }
41121 arg1 = reinterpret_cast< wxMenu * >(argp1);
41122 {
41123 PyThreadState* __tstate = wxPyBeginAllowThreads();
41124 result = (PyObject *)wxMenu_GetMenuItems(arg1);
41125 wxPyEndAllowThreads(__tstate);
41126 if (PyErr_Occurred()) SWIG_fail;
41127 }
41128 resultobj = result;
41129 return resultobj;
41130 fail:
41131 return NULL;
41132 }
41133
41134
41135 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41136 PyObject *resultobj = 0;
41137 wxMenu *arg1 = (wxMenu *) 0 ;
41138 wxString *arg2 = 0 ;
41139 int result;
41140 void *argp1 = 0 ;
41141 int res1 = 0 ;
41142 bool temp2 = false ;
41143 PyObject * obj0 = 0 ;
41144 PyObject * obj1 = 0 ;
41145 char * kwnames[] = {
41146 (char *) "self",(char *) "item", NULL
41147 };
41148
41149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
41150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41151 if (!SWIG_IsOK(res1)) {
41152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
41153 }
41154 arg1 = reinterpret_cast< wxMenu * >(argp1);
41155 {
41156 arg2 = wxString_in_helper(obj1);
41157 if (arg2 == NULL) SWIG_fail;
41158 temp2 = true;
41159 }
41160 {
41161 PyThreadState* __tstate = wxPyBeginAllowThreads();
41162 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
41163 wxPyEndAllowThreads(__tstate);
41164 if (PyErr_Occurred()) SWIG_fail;
41165 }
41166 resultobj = SWIG_From_int(static_cast< int >(result));
41167 {
41168 if (temp2)
41169 delete arg2;
41170 }
41171 return resultobj;
41172 fail:
41173 {
41174 if (temp2)
41175 delete arg2;
41176 }
41177 return NULL;
41178 }
41179
41180
41181 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41182 PyObject *resultobj = 0;
41183 wxMenu *arg1 = (wxMenu *) 0 ;
41184 int arg2 ;
41185 wxMenuItem *result = 0 ;
41186 void *argp1 = 0 ;
41187 int res1 = 0 ;
41188 int val2 ;
41189 int ecode2 = 0 ;
41190 PyObject * obj0 = 0 ;
41191 PyObject * obj1 = 0 ;
41192 char * kwnames[] = {
41193 (char *) "self",(char *) "id", NULL
41194 };
41195
41196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41198 if (!SWIG_IsOK(res1)) {
41199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
41200 }
41201 arg1 = reinterpret_cast< wxMenu * >(argp1);
41202 ecode2 = SWIG_AsVal_int(obj1, &val2);
41203 if (!SWIG_IsOK(ecode2)) {
41204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
41205 }
41206 arg2 = static_cast< int >(val2);
41207 {
41208 PyThreadState* __tstate = wxPyBeginAllowThreads();
41209 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
41210 wxPyEndAllowThreads(__tstate);
41211 if (PyErr_Occurred()) SWIG_fail;
41212 }
41213 {
41214 resultobj = wxPyMake_wxObject(result, (bool)0);
41215 }
41216 return resultobj;
41217 fail:
41218 return NULL;
41219 }
41220
41221
41222 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41223 PyObject *resultobj = 0;
41224 wxMenu *arg1 = (wxMenu *) 0 ;
41225 size_t arg2 ;
41226 wxMenuItem *result = 0 ;
41227 void *argp1 = 0 ;
41228 int res1 = 0 ;
41229 size_t val2 ;
41230 int ecode2 = 0 ;
41231 PyObject * obj0 = 0 ;
41232 PyObject * obj1 = 0 ;
41233 char * kwnames[] = {
41234 (char *) "self",(char *) "position", NULL
41235 };
41236
41237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
41238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41239 if (!SWIG_IsOK(res1)) {
41240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
41241 }
41242 arg1 = reinterpret_cast< wxMenu * >(argp1);
41243 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41244 if (!SWIG_IsOK(ecode2)) {
41245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
41246 }
41247 arg2 = static_cast< size_t >(val2);
41248 {
41249 PyThreadState* __tstate = wxPyBeginAllowThreads();
41250 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
41251 wxPyEndAllowThreads(__tstate);
41252 if (PyErr_Occurred()) SWIG_fail;
41253 }
41254 {
41255 resultobj = wxPyMake_wxObject(result, (bool)0);
41256 }
41257 return resultobj;
41258 fail:
41259 return NULL;
41260 }
41261
41262
41263 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41264 PyObject *resultobj = 0;
41265 wxMenu *arg1 = (wxMenu *) 0 ;
41266 int arg2 ;
41267 bool arg3 ;
41268 void *argp1 = 0 ;
41269 int res1 = 0 ;
41270 int val2 ;
41271 int ecode2 = 0 ;
41272 bool val3 ;
41273 int ecode3 = 0 ;
41274 PyObject * obj0 = 0 ;
41275 PyObject * obj1 = 0 ;
41276 PyObject * obj2 = 0 ;
41277 char * kwnames[] = {
41278 (char *) "self",(char *) "id",(char *) "enable", NULL
41279 };
41280
41281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41283 if (!SWIG_IsOK(res1)) {
41284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
41285 }
41286 arg1 = reinterpret_cast< wxMenu * >(argp1);
41287 ecode2 = SWIG_AsVal_int(obj1, &val2);
41288 if (!SWIG_IsOK(ecode2)) {
41289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
41290 }
41291 arg2 = static_cast< int >(val2);
41292 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41293 if (!SWIG_IsOK(ecode3)) {
41294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
41295 }
41296 arg3 = static_cast< bool >(val3);
41297 {
41298 PyThreadState* __tstate = wxPyBeginAllowThreads();
41299 (arg1)->Enable(arg2,arg3);
41300 wxPyEndAllowThreads(__tstate);
41301 if (PyErr_Occurred()) SWIG_fail;
41302 }
41303 resultobj = SWIG_Py_Void();
41304 return resultobj;
41305 fail:
41306 return NULL;
41307 }
41308
41309
41310 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41311 PyObject *resultobj = 0;
41312 wxMenu *arg1 = (wxMenu *) 0 ;
41313 int arg2 ;
41314 bool result;
41315 void *argp1 = 0 ;
41316 int res1 = 0 ;
41317 int val2 ;
41318 int ecode2 = 0 ;
41319 PyObject * obj0 = 0 ;
41320 PyObject * obj1 = 0 ;
41321 char * kwnames[] = {
41322 (char *) "self",(char *) "id", NULL
41323 };
41324
41325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41327 if (!SWIG_IsOK(res1)) {
41328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
41329 }
41330 arg1 = reinterpret_cast< wxMenu * >(argp1);
41331 ecode2 = SWIG_AsVal_int(obj1, &val2);
41332 if (!SWIG_IsOK(ecode2)) {
41333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41334 }
41335 arg2 = static_cast< int >(val2);
41336 {
41337 PyThreadState* __tstate = wxPyBeginAllowThreads();
41338 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
41339 wxPyEndAllowThreads(__tstate);
41340 if (PyErr_Occurred()) SWIG_fail;
41341 }
41342 {
41343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41344 }
41345 return resultobj;
41346 fail:
41347 return NULL;
41348 }
41349
41350
41351 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41352 PyObject *resultobj = 0;
41353 wxMenu *arg1 = (wxMenu *) 0 ;
41354 int arg2 ;
41355 bool arg3 ;
41356 void *argp1 = 0 ;
41357 int res1 = 0 ;
41358 int val2 ;
41359 int ecode2 = 0 ;
41360 bool val3 ;
41361 int ecode3 = 0 ;
41362 PyObject * obj0 = 0 ;
41363 PyObject * obj1 = 0 ;
41364 PyObject * obj2 = 0 ;
41365 char * kwnames[] = {
41366 (char *) "self",(char *) "id",(char *) "check", NULL
41367 };
41368
41369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41371 if (!SWIG_IsOK(res1)) {
41372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
41373 }
41374 arg1 = reinterpret_cast< wxMenu * >(argp1);
41375 ecode2 = SWIG_AsVal_int(obj1, &val2);
41376 if (!SWIG_IsOK(ecode2)) {
41377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
41378 }
41379 arg2 = static_cast< int >(val2);
41380 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41381 if (!SWIG_IsOK(ecode3)) {
41382 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
41383 }
41384 arg3 = static_cast< bool >(val3);
41385 {
41386 PyThreadState* __tstate = wxPyBeginAllowThreads();
41387 (arg1)->Check(arg2,arg3);
41388 wxPyEndAllowThreads(__tstate);
41389 if (PyErr_Occurred()) SWIG_fail;
41390 }
41391 resultobj = SWIG_Py_Void();
41392 return resultobj;
41393 fail:
41394 return NULL;
41395 }
41396
41397
41398 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41399 PyObject *resultobj = 0;
41400 wxMenu *arg1 = (wxMenu *) 0 ;
41401 int arg2 ;
41402 bool result;
41403 void *argp1 = 0 ;
41404 int res1 = 0 ;
41405 int val2 ;
41406 int ecode2 = 0 ;
41407 PyObject * obj0 = 0 ;
41408 PyObject * obj1 = 0 ;
41409 char * kwnames[] = {
41410 (char *) "self",(char *) "id", NULL
41411 };
41412
41413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41415 if (!SWIG_IsOK(res1)) {
41416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
41417 }
41418 arg1 = reinterpret_cast< wxMenu * >(argp1);
41419 ecode2 = SWIG_AsVal_int(obj1, &val2);
41420 if (!SWIG_IsOK(ecode2)) {
41421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
41422 }
41423 arg2 = static_cast< int >(val2);
41424 {
41425 PyThreadState* __tstate = wxPyBeginAllowThreads();
41426 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
41427 wxPyEndAllowThreads(__tstate);
41428 if (PyErr_Occurred()) SWIG_fail;
41429 }
41430 {
41431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41432 }
41433 return resultobj;
41434 fail:
41435 return NULL;
41436 }
41437
41438
41439 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41440 PyObject *resultobj = 0;
41441 wxMenu *arg1 = (wxMenu *) 0 ;
41442 int arg2 ;
41443 wxString *arg3 = 0 ;
41444 void *argp1 = 0 ;
41445 int res1 = 0 ;
41446 int val2 ;
41447 int ecode2 = 0 ;
41448 bool temp3 = false ;
41449 PyObject * obj0 = 0 ;
41450 PyObject * obj1 = 0 ;
41451 PyObject * obj2 = 0 ;
41452 char * kwnames[] = {
41453 (char *) "self",(char *) "id",(char *) "label", NULL
41454 };
41455
41456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41458 if (!SWIG_IsOK(res1)) {
41459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41460 }
41461 arg1 = reinterpret_cast< wxMenu * >(argp1);
41462 ecode2 = SWIG_AsVal_int(obj1, &val2);
41463 if (!SWIG_IsOK(ecode2)) {
41464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41465 }
41466 arg2 = static_cast< int >(val2);
41467 {
41468 arg3 = wxString_in_helper(obj2);
41469 if (arg3 == NULL) SWIG_fail;
41470 temp3 = true;
41471 }
41472 {
41473 PyThreadState* __tstate = wxPyBeginAllowThreads();
41474 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41475 wxPyEndAllowThreads(__tstate);
41476 if (PyErr_Occurred()) SWIG_fail;
41477 }
41478 resultobj = SWIG_Py_Void();
41479 {
41480 if (temp3)
41481 delete arg3;
41482 }
41483 return resultobj;
41484 fail:
41485 {
41486 if (temp3)
41487 delete arg3;
41488 }
41489 return NULL;
41490 }
41491
41492
41493 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41494 PyObject *resultobj = 0;
41495 wxMenu *arg1 = (wxMenu *) 0 ;
41496 int arg2 ;
41497 wxString result;
41498 void *argp1 = 0 ;
41499 int res1 = 0 ;
41500 int val2 ;
41501 int ecode2 = 0 ;
41502 PyObject * obj0 = 0 ;
41503 PyObject * obj1 = 0 ;
41504 char * kwnames[] = {
41505 (char *) "self",(char *) "id", NULL
41506 };
41507
41508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41510 if (!SWIG_IsOK(res1)) {
41511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41512 }
41513 arg1 = reinterpret_cast< wxMenu * >(argp1);
41514 ecode2 = SWIG_AsVal_int(obj1, &val2);
41515 if (!SWIG_IsOK(ecode2)) {
41516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41517 }
41518 arg2 = static_cast< int >(val2);
41519 {
41520 PyThreadState* __tstate = wxPyBeginAllowThreads();
41521 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41522 wxPyEndAllowThreads(__tstate);
41523 if (PyErr_Occurred()) SWIG_fail;
41524 }
41525 {
41526 #if wxUSE_UNICODE
41527 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41528 #else
41529 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41530 #endif
41531 }
41532 return resultobj;
41533 fail:
41534 return NULL;
41535 }
41536
41537
41538 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41539 PyObject *resultobj = 0;
41540 wxMenu *arg1 = (wxMenu *) 0 ;
41541 int arg2 ;
41542 wxString *arg3 = 0 ;
41543 void *argp1 = 0 ;
41544 int res1 = 0 ;
41545 int val2 ;
41546 int ecode2 = 0 ;
41547 bool temp3 = false ;
41548 PyObject * obj0 = 0 ;
41549 PyObject * obj1 = 0 ;
41550 PyObject * obj2 = 0 ;
41551 char * kwnames[] = {
41552 (char *) "self",(char *) "id",(char *) "helpString", NULL
41553 };
41554
41555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41557 if (!SWIG_IsOK(res1)) {
41558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41559 }
41560 arg1 = reinterpret_cast< wxMenu * >(argp1);
41561 ecode2 = SWIG_AsVal_int(obj1, &val2);
41562 if (!SWIG_IsOK(ecode2)) {
41563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41564 }
41565 arg2 = static_cast< int >(val2);
41566 {
41567 arg3 = wxString_in_helper(obj2);
41568 if (arg3 == NULL) SWIG_fail;
41569 temp3 = true;
41570 }
41571 {
41572 PyThreadState* __tstate = wxPyBeginAllowThreads();
41573 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41574 wxPyEndAllowThreads(__tstate);
41575 if (PyErr_Occurred()) SWIG_fail;
41576 }
41577 resultobj = SWIG_Py_Void();
41578 {
41579 if (temp3)
41580 delete arg3;
41581 }
41582 return resultobj;
41583 fail:
41584 {
41585 if (temp3)
41586 delete arg3;
41587 }
41588 return NULL;
41589 }
41590
41591
41592 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41593 PyObject *resultobj = 0;
41594 wxMenu *arg1 = (wxMenu *) 0 ;
41595 int arg2 ;
41596 wxString result;
41597 void *argp1 = 0 ;
41598 int res1 = 0 ;
41599 int val2 ;
41600 int ecode2 = 0 ;
41601 PyObject * obj0 = 0 ;
41602 PyObject * obj1 = 0 ;
41603 char * kwnames[] = {
41604 (char *) "self",(char *) "id", NULL
41605 };
41606
41607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41609 if (!SWIG_IsOK(res1)) {
41610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41611 }
41612 arg1 = reinterpret_cast< wxMenu * >(argp1);
41613 ecode2 = SWIG_AsVal_int(obj1, &val2);
41614 if (!SWIG_IsOK(ecode2)) {
41615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41616 }
41617 arg2 = static_cast< int >(val2);
41618 {
41619 PyThreadState* __tstate = wxPyBeginAllowThreads();
41620 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41621 wxPyEndAllowThreads(__tstate);
41622 if (PyErr_Occurred()) SWIG_fail;
41623 }
41624 {
41625 #if wxUSE_UNICODE
41626 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41627 #else
41628 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41629 #endif
41630 }
41631 return resultobj;
41632 fail:
41633 return NULL;
41634 }
41635
41636
41637 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41638 PyObject *resultobj = 0;
41639 wxMenu *arg1 = (wxMenu *) 0 ;
41640 wxString *arg2 = 0 ;
41641 void *argp1 = 0 ;
41642 int res1 = 0 ;
41643 bool temp2 = false ;
41644 PyObject * obj0 = 0 ;
41645 PyObject * obj1 = 0 ;
41646 char * kwnames[] = {
41647 (char *) "self",(char *) "title", NULL
41648 };
41649
41650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41652 if (!SWIG_IsOK(res1)) {
41653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41654 }
41655 arg1 = reinterpret_cast< wxMenu * >(argp1);
41656 {
41657 arg2 = wxString_in_helper(obj1);
41658 if (arg2 == NULL) SWIG_fail;
41659 temp2 = true;
41660 }
41661 {
41662 PyThreadState* __tstate = wxPyBeginAllowThreads();
41663 (arg1)->SetTitle((wxString const &)*arg2);
41664 wxPyEndAllowThreads(__tstate);
41665 if (PyErr_Occurred()) SWIG_fail;
41666 }
41667 resultobj = SWIG_Py_Void();
41668 {
41669 if (temp2)
41670 delete arg2;
41671 }
41672 return resultobj;
41673 fail:
41674 {
41675 if (temp2)
41676 delete arg2;
41677 }
41678 return NULL;
41679 }
41680
41681
41682 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41683 PyObject *resultobj = 0;
41684 wxMenu *arg1 = (wxMenu *) 0 ;
41685 wxString result;
41686 void *argp1 = 0 ;
41687 int res1 = 0 ;
41688 PyObject *swig_obj[1] ;
41689
41690 if (!args) SWIG_fail;
41691 swig_obj[0] = args;
41692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41693 if (!SWIG_IsOK(res1)) {
41694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41695 }
41696 arg1 = reinterpret_cast< wxMenu * >(argp1);
41697 {
41698 PyThreadState* __tstate = wxPyBeginAllowThreads();
41699 result = ((wxMenu const *)arg1)->GetTitle();
41700 wxPyEndAllowThreads(__tstate);
41701 if (PyErr_Occurred()) SWIG_fail;
41702 }
41703 {
41704 #if wxUSE_UNICODE
41705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41706 #else
41707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41708 #endif
41709 }
41710 return resultobj;
41711 fail:
41712 return NULL;
41713 }
41714
41715
41716 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41717 PyObject *resultobj = 0;
41718 wxMenu *arg1 = (wxMenu *) 0 ;
41719 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41720 void *argp1 = 0 ;
41721 int res1 = 0 ;
41722 void *argp2 = 0 ;
41723 int res2 = 0 ;
41724 PyObject * obj0 = 0 ;
41725 PyObject * obj1 = 0 ;
41726 char * kwnames[] = {
41727 (char *) "self",(char *) "handler", NULL
41728 };
41729
41730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41732 if (!SWIG_IsOK(res1)) {
41733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41734 }
41735 arg1 = reinterpret_cast< wxMenu * >(argp1);
41736 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41737 if (!SWIG_IsOK(res2)) {
41738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41739 }
41740 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41741 {
41742 PyThreadState* __tstate = wxPyBeginAllowThreads();
41743 (arg1)->SetEventHandler(arg2);
41744 wxPyEndAllowThreads(__tstate);
41745 if (PyErr_Occurred()) SWIG_fail;
41746 }
41747 resultobj = SWIG_Py_Void();
41748 return resultobj;
41749 fail:
41750 return NULL;
41751 }
41752
41753
41754 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41755 PyObject *resultobj = 0;
41756 wxMenu *arg1 = (wxMenu *) 0 ;
41757 wxEvtHandler *result = 0 ;
41758 void *argp1 = 0 ;
41759 int res1 = 0 ;
41760 PyObject *swig_obj[1] ;
41761
41762 if (!args) SWIG_fail;
41763 swig_obj[0] = args;
41764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41765 if (!SWIG_IsOK(res1)) {
41766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41767 }
41768 arg1 = reinterpret_cast< wxMenu * >(argp1);
41769 {
41770 PyThreadState* __tstate = wxPyBeginAllowThreads();
41771 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41772 wxPyEndAllowThreads(__tstate);
41773 if (PyErr_Occurred()) SWIG_fail;
41774 }
41775 {
41776 resultobj = wxPyMake_wxObject(result, 0);
41777 }
41778 return resultobj;
41779 fail:
41780 return NULL;
41781 }
41782
41783
41784 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41785 PyObject *resultobj = 0;
41786 wxMenu *arg1 = (wxMenu *) 0 ;
41787 wxWindow *arg2 = (wxWindow *) 0 ;
41788 void *argp1 = 0 ;
41789 int res1 = 0 ;
41790 void *argp2 = 0 ;
41791 int res2 = 0 ;
41792 PyObject * obj0 = 0 ;
41793 PyObject * obj1 = 0 ;
41794 char * kwnames[] = {
41795 (char *) "self",(char *) "win", NULL
41796 };
41797
41798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41800 if (!SWIG_IsOK(res1)) {
41801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41802 }
41803 arg1 = reinterpret_cast< wxMenu * >(argp1);
41804 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41805 if (!SWIG_IsOK(res2)) {
41806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41807 }
41808 arg2 = reinterpret_cast< wxWindow * >(argp2);
41809 {
41810 PyThreadState* __tstate = wxPyBeginAllowThreads();
41811 (arg1)->SetInvokingWindow(arg2);
41812 wxPyEndAllowThreads(__tstate);
41813 if (PyErr_Occurred()) SWIG_fail;
41814 }
41815 resultobj = SWIG_Py_Void();
41816 return resultobj;
41817 fail:
41818 return NULL;
41819 }
41820
41821
41822 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41823 PyObject *resultobj = 0;
41824 wxMenu *arg1 = (wxMenu *) 0 ;
41825 wxWindow *result = 0 ;
41826 void *argp1 = 0 ;
41827 int res1 = 0 ;
41828 PyObject *swig_obj[1] ;
41829
41830 if (!args) SWIG_fail;
41831 swig_obj[0] = args;
41832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41833 if (!SWIG_IsOK(res1)) {
41834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41835 }
41836 arg1 = reinterpret_cast< wxMenu * >(argp1);
41837 {
41838 PyThreadState* __tstate = wxPyBeginAllowThreads();
41839 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41840 wxPyEndAllowThreads(__tstate);
41841 if (PyErr_Occurred()) SWIG_fail;
41842 }
41843 {
41844 resultobj = wxPyMake_wxObject(result, 0);
41845 }
41846 return resultobj;
41847 fail:
41848 return NULL;
41849 }
41850
41851
41852 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41853 PyObject *resultobj = 0;
41854 wxMenu *arg1 = (wxMenu *) 0 ;
41855 long result;
41856 void *argp1 = 0 ;
41857 int res1 = 0 ;
41858 PyObject *swig_obj[1] ;
41859
41860 if (!args) SWIG_fail;
41861 swig_obj[0] = args;
41862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41863 if (!SWIG_IsOK(res1)) {
41864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41865 }
41866 arg1 = reinterpret_cast< wxMenu * >(argp1);
41867 {
41868 PyThreadState* __tstate = wxPyBeginAllowThreads();
41869 result = (long)((wxMenu const *)arg1)->GetStyle();
41870 wxPyEndAllowThreads(__tstate);
41871 if (PyErr_Occurred()) SWIG_fail;
41872 }
41873 resultobj = SWIG_From_long(static_cast< long >(result));
41874 return resultobj;
41875 fail:
41876 return NULL;
41877 }
41878
41879
41880 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41881 PyObject *resultobj = 0;
41882 wxMenu *arg1 = (wxMenu *) 0 ;
41883 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41884 void *argp1 = 0 ;
41885 int res1 = 0 ;
41886 void *argp2 = 0 ;
41887 int res2 = 0 ;
41888 PyObject * obj0 = 0 ;
41889 PyObject * obj1 = 0 ;
41890 char * kwnames[] = {
41891 (char *) "self",(char *) "source", NULL
41892 };
41893
41894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41896 if (!SWIG_IsOK(res1)) {
41897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41898 }
41899 arg1 = reinterpret_cast< wxMenu * >(argp1);
41900 if (obj1) {
41901 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41902 if (!SWIG_IsOK(res2)) {
41903 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41904 }
41905 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41906 }
41907 {
41908 PyThreadState* __tstate = wxPyBeginAllowThreads();
41909 (arg1)->UpdateUI(arg2);
41910 wxPyEndAllowThreads(__tstate);
41911 if (PyErr_Occurred()) SWIG_fail;
41912 }
41913 resultobj = SWIG_Py_Void();
41914 return resultobj;
41915 fail:
41916 return NULL;
41917 }
41918
41919
41920 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41921 PyObject *resultobj = 0;
41922 wxMenu *arg1 = (wxMenu *) 0 ;
41923 wxMenuBar *result = 0 ;
41924 void *argp1 = 0 ;
41925 int res1 = 0 ;
41926 PyObject *swig_obj[1] ;
41927
41928 if (!args) SWIG_fail;
41929 swig_obj[0] = args;
41930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41931 if (!SWIG_IsOK(res1)) {
41932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41933 }
41934 arg1 = reinterpret_cast< wxMenu * >(argp1);
41935 {
41936 PyThreadState* __tstate = wxPyBeginAllowThreads();
41937 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41938 wxPyEndAllowThreads(__tstate);
41939 if (PyErr_Occurred()) SWIG_fail;
41940 }
41941 {
41942 resultobj = wxPyMake_wxObject(result, (bool)0);
41943 }
41944 return resultobj;
41945 fail:
41946 return NULL;
41947 }
41948
41949
41950 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41951 PyObject *resultobj = 0;
41952 wxMenu *arg1 = (wxMenu *) 0 ;
41953 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41954 void *argp1 = 0 ;
41955 int res1 = 0 ;
41956 void *argp2 = 0 ;
41957 int res2 = 0 ;
41958 PyObject * obj0 = 0 ;
41959 PyObject * obj1 = 0 ;
41960 char * kwnames[] = {
41961 (char *) "self",(char *) "menubar", NULL
41962 };
41963
41964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41966 if (!SWIG_IsOK(res1)) {
41967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41968 }
41969 arg1 = reinterpret_cast< wxMenu * >(argp1);
41970 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41971 if (!SWIG_IsOK(res2)) {
41972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41973 }
41974 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41975 {
41976 PyThreadState* __tstate = wxPyBeginAllowThreads();
41977 (arg1)->Attach(arg2);
41978 wxPyEndAllowThreads(__tstate);
41979 if (PyErr_Occurred()) SWIG_fail;
41980 }
41981 resultobj = SWIG_Py_Void();
41982 return resultobj;
41983 fail:
41984 return NULL;
41985 }
41986
41987
41988 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41989 PyObject *resultobj = 0;
41990 wxMenu *arg1 = (wxMenu *) 0 ;
41991 void *argp1 = 0 ;
41992 int res1 = 0 ;
41993 PyObject *swig_obj[1] ;
41994
41995 if (!args) SWIG_fail;
41996 swig_obj[0] = args;
41997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41998 if (!SWIG_IsOK(res1)) {
41999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
42000 }
42001 arg1 = reinterpret_cast< wxMenu * >(argp1);
42002 {
42003 PyThreadState* __tstate = wxPyBeginAllowThreads();
42004 (arg1)->Detach();
42005 wxPyEndAllowThreads(__tstate);
42006 if (PyErr_Occurred()) SWIG_fail;
42007 }
42008 resultobj = SWIG_Py_Void();
42009 return resultobj;
42010 fail:
42011 return NULL;
42012 }
42013
42014
42015 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42016 PyObject *resultobj = 0;
42017 wxMenu *arg1 = (wxMenu *) 0 ;
42018 bool result;
42019 void *argp1 = 0 ;
42020 int res1 = 0 ;
42021 PyObject *swig_obj[1] ;
42022
42023 if (!args) SWIG_fail;
42024 swig_obj[0] = args;
42025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42026 if (!SWIG_IsOK(res1)) {
42027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
42028 }
42029 arg1 = reinterpret_cast< wxMenu * >(argp1);
42030 {
42031 PyThreadState* __tstate = wxPyBeginAllowThreads();
42032 result = (bool)((wxMenu const *)arg1)->IsAttached();
42033 wxPyEndAllowThreads(__tstate);
42034 if (PyErr_Occurred()) SWIG_fail;
42035 }
42036 {
42037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42038 }
42039 return resultobj;
42040 fail:
42041 return NULL;
42042 }
42043
42044
42045 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42046 PyObject *resultobj = 0;
42047 wxMenu *arg1 = (wxMenu *) 0 ;
42048 wxMenu *arg2 = (wxMenu *) 0 ;
42049 void *argp1 = 0 ;
42050 int res1 = 0 ;
42051 void *argp2 = 0 ;
42052 int res2 = 0 ;
42053 PyObject * obj0 = 0 ;
42054 PyObject * obj1 = 0 ;
42055 char * kwnames[] = {
42056 (char *) "self",(char *) "parent", NULL
42057 };
42058
42059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
42060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42061 if (!SWIG_IsOK(res1)) {
42062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
42063 }
42064 arg1 = reinterpret_cast< wxMenu * >(argp1);
42065 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42066 if (!SWIG_IsOK(res2)) {
42067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
42068 }
42069 arg2 = reinterpret_cast< wxMenu * >(argp2);
42070 {
42071 PyThreadState* __tstate = wxPyBeginAllowThreads();
42072 (arg1)->SetParent(arg2);
42073 wxPyEndAllowThreads(__tstate);
42074 if (PyErr_Occurred()) SWIG_fail;
42075 }
42076 resultobj = SWIG_Py_Void();
42077 return resultobj;
42078 fail:
42079 return NULL;
42080 }
42081
42082
42083 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42084 PyObject *resultobj = 0;
42085 wxMenu *arg1 = (wxMenu *) 0 ;
42086 wxMenu *result = 0 ;
42087 void *argp1 = 0 ;
42088 int res1 = 0 ;
42089 PyObject *swig_obj[1] ;
42090
42091 if (!args) SWIG_fail;
42092 swig_obj[0] = args;
42093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42094 if (!SWIG_IsOK(res1)) {
42095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
42096 }
42097 arg1 = reinterpret_cast< wxMenu * >(argp1);
42098 {
42099 PyThreadState* __tstate = wxPyBeginAllowThreads();
42100 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
42101 wxPyEndAllowThreads(__tstate);
42102 if (PyErr_Occurred()) SWIG_fail;
42103 }
42104 {
42105 resultobj = wxPyMake_wxObject(result, 0);
42106 }
42107 return resultobj;
42108 fail:
42109 return NULL;
42110 }
42111
42112
42113 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42114 PyObject *obj;
42115 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42116 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
42117 return SWIG_Py_Void();
42118 }
42119
42120 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42121 return SWIG_Python_InitShadowInstance(args);
42122 }
42123
42124 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42125 PyObject *resultobj = 0;
42126 long arg1 = (long) 0 ;
42127 wxMenuBar *result = 0 ;
42128 long val1 ;
42129 int ecode1 = 0 ;
42130 PyObject * obj0 = 0 ;
42131 char * kwnames[] = {
42132 (char *) "style", NULL
42133 };
42134
42135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
42136 if (obj0) {
42137 ecode1 = SWIG_AsVal_long(obj0, &val1);
42138 if (!SWIG_IsOK(ecode1)) {
42139 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
42140 }
42141 arg1 = static_cast< long >(val1);
42142 }
42143 {
42144 if (!wxPyCheckForApp()) SWIG_fail;
42145 PyThreadState* __tstate = wxPyBeginAllowThreads();
42146 result = (wxMenuBar *)new wxMenuBar(arg1);
42147 wxPyEndAllowThreads(__tstate);
42148 if (PyErr_Occurred()) SWIG_fail;
42149 }
42150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
42151 return resultobj;
42152 fail:
42153 return NULL;
42154 }
42155
42156
42157 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42158 PyObject *resultobj = 0;
42159 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42160 wxMenu *arg2 = (wxMenu *) 0 ;
42161 wxString *arg3 = 0 ;
42162 bool result;
42163 void *argp1 = 0 ;
42164 int res1 = 0 ;
42165 void *argp2 = 0 ;
42166 int res2 = 0 ;
42167 bool temp3 = false ;
42168 PyObject * obj0 = 0 ;
42169 PyObject * obj1 = 0 ;
42170 PyObject * obj2 = 0 ;
42171 char * kwnames[] = {
42172 (char *) "self",(char *) "menu",(char *) "title", NULL
42173 };
42174
42175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42177 if (!SWIG_IsOK(res1)) {
42178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42179 }
42180 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42181 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42182 if (!SWIG_IsOK(res2)) {
42183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
42184 }
42185 arg2 = reinterpret_cast< wxMenu * >(argp2);
42186 {
42187 arg3 = wxString_in_helper(obj2);
42188 if (arg3 == NULL) SWIG_fail;
42189 temp3 = true;
42190 }
42191 {
42192 PyThreadState* __tstate = wxPyBeginAllowThreads();
42193 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
42194 wxPyEndAllowThreads(__tstate);
42195 if (PyErr_Occurred()) SWIG_fail;
42196 }
42197 {
42198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42199 }
42200 {
42201 if (temp3)
42202 delete arg3;
42203 }
42204 return resultobj;
42205 fail:
42206 {
42207 if (temp3)
42208 delete arg3;
42209 }
42210 return NULL;
42211 }
42212
42213
42214 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42215 PyObject *resultobj = 0;
42216 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42217 size_t arg2 ;
42218 wxMenu *arg3 = (wxMenu *) 0 ;
42219 wxString *arg4 = 0 ;
42220 bool result;
42221 void *argp1 = 0 ;
42222 int res1 = 0 ;
42223 size_t val2 ;
42224 int ecode2 = 0 ;
42225 void *argp3 = 0 ;
42226 int res3 = 0 ;
42227 bool temp4 = false ;
42228 PyObject * obj0 = 0 ;
42229 PyObject * obj1 = 0 ;
42230 PyObject * obj2 = 0 ;
42231 PyObject * obj3 = 0 ;
42232 char * kwnames[] = {
42233 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42234 };
42235
42236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42238 if (!SWIG_IsOK(res1)) {
42239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42240 }
42241 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42242 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42243 if (!SWIG_IsOK(ecode2)) {
42244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
42245 }
42246 arg2 = static_cast< size_t >(val2);
42247 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42248 if (!SWIG_IsOK(res3)) {
42249 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
42250 }
42251 arg3 = reinterpret_cast< wxMenu * >(argp3);
42252 {
42253 arg4 = wxString_in_helper(obj3);
42254 if (arg4 == NULL) SWIG_fail;
42255 temp4 = true;
42256 }
42257 {
42258 PyThreadState* __tstate = wxPyBeginAllowThreads();
42259 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
42260 wxPyEndAllowThreads(__tstate);
42261 if (PyErr_Occurred()) SWIG_fail;
42262 }
42263 {
42264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42265 }
42266 {
42267 if (temp4)
42268 delete arg4;
42269 }
42270 return resultobj;
42271 fail:
42272 {
42273 if (temp4)
42274 delete arg4;
42275 }
42276 return NULL;
42277 }
42278
42279
42280 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42281 PyObject *resultobj = 0;
42282 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42283 size_t result;
42284 void *argp1 = 0 ;
42285 int res1 = 0 ;
42286 PyObject *swig_obj[1] ;
42287
42288 if (!args) SWIG_fail;
42289 swig_obj[0] = args;
42290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42291 if (!SWIG_IsOK(res1)) {
42292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42293 }
42294 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42295 {
42296 PyThreadState* __tstate = wxPyBeginAllowThreads();
42297 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
42298 wxPyEndAllowThreads(__tstate);
42299 if (PyErr_Occurred()) SWIG_fail;
42300 }
42301 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
42302 return resultobj;
42303 fail:
42304 return NULL;
42305 }
42306
42307
42308 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42309 PyObject *resultobj = 0;
42310 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42311 size_t arg2 ;
42312 wxMenu *result = 0 ;
42313 void *argp1 = 0 ;
42314 int res1 = 0 ;
42315 size_t val2 ;
42316 int ecode2 = 0 ;
42317 PyObject * obj0 = 0 ;
42318 PyObject * obj1 = 0 ;
42319 char * kwnames[] = {
42320 (char *) "self",(char *) "pos", NULL
42321 };
42322
42323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42325 if (!SWIG_IsOK(res1)) {
42326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42327 }
42328 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42329 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42330 if (!SWIG_IsOK(ecode2)) {
42331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
42332 }
42333 arg2 = static_cast< size_t >(val2);
42334 {
42335 PyThreadState* __tstate = wxPyBeginAllowThreads();
42336 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
42337 wxPyEndAllowThreads(__tstate);
42338 if (PyErr_Occurred()) SWIG_fail;
42339 }
42340 {
42341 resultobj = wxPyMake_wxObject(result, 0);
42342 }
42343 return resultobj;
42344 fail:
42345 return NULL;
42346 }
42347
42348
42349 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42350 PyObject *resultobj = 0;
42351 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42352 size_t arg2 ;
42353 wxMenu *arg3 = (wxMenu *) 0 ;
42354 wxString *arg4 = 0 ;
42355 wxMenu *result = 0 ;
42356 void *argp1 = 0 ;
42357 int res1 = 0 ;
42358 size_t val2 ;
42359 int ecode2 = 0 ;
42360 void *argp3 = 0 ;
42361 int res3 = 0 ;
42362 bool temp4 = false ;
42363 PyObject * obj0 = 0 ;
42364 PyObject * obj1 = 0 ;
42365 PyObject * obj2 = 0 ;
42366 PyObject * obj3 = 0 ;
42367 char * kwnames[] = {
42368 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42369 };
42370
42371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42373 if (!SWIG_IsOK(res1)) {
42374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42375 }
42376 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42377 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42378 if (!SWIG_IsOK(ecode2)) {
42379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
42380 }
42381 arg2 = static_cast< size_t >(val2);
42382 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42383 if (!SWIG_IsOK(res3)) {
42384 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
42385 }
42386 arg3 = reinterpret_cast< wxMenu * >(argp3);
42387 {
42388 arg4 = wxString_in_helper(obj3);
42389 if (arg4 == NULL) SWIG_fail;
42390 temp4 = true;
42391 }
42392 {
42393 PyThreadState* __tstate = wxPyBeginAllowThreads();
42394 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
42395 wxPyEndAllowThreads(__tstate);
42396 if (PyErr_Occurred()) SWIG_fail;
42397 }
42398 {
42399 resultobj = wxPyMake_wxObject(result, 0);
42400 }
42401 {
42402 if (temp4)
42403 delete arg4;
42404 }
42405 return resultobj;
42406 fail:
42407 {
42408 if (temp4)
42409 delete arg4;
42410 }
42411 return NULL;
42412 }
42413
42414
42415 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42416 PyObject *resultobj = 0;
42417 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42418 size_t arg2 ;
42419 wxMenu *result = 0 ;
42420 void *argp1 = 0 ;
42421 int res1 = 0 ;
42422 size_t val2 ;
42423 int ecode2 = 0 ;
42424 PyObject * obj0 = 0 ;
42425 PyObject * obj1 = 0 ;
42426 char * kwnames[] = {
42427 (char *) "self",(char *) "pos", NULL
42428 };
42429
42430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
42431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42432 if (!SWIG_IsOK(res1)) {
42433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42434 }
42435 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42436 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42437 if (!SWIG_IsOK(ecode2)) {
42438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
42439 }
42440 arg2 = static_cast< size_t >(val2);
42441 {
42442 PyThreadState* __tstate = wxPyBeginAllowThreads();
42443 result = (wxMenu *)(arg1)->Remove(arg2);
42444 wxPyEndAllowThreads(__tstate);
42445 if (PyErr_Occurred()) SWIG_fail;
42446 }
42447 {
42448 resultobj = wxPyMake_wxObject(result, 0);
42449 }
42450 return resultobj;
42451 fail:
42452 return NULL;
42453 }
42454
42455
42456 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42457 PyObject *resultobj = 0;
42458 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42459 size_t arg2 ;
42460 bool arg3 ;
42461 void *argp1 = 0 ;
42462 int res1 = 0 ;
42463 size_t val2 ;
42464 int ecode2 = 0 ;
42465 bool val3 ;
42466 int ecode3 = 0 ;
42467 PyObject * obj0 = 0 ;
42468 PyObject * obj1 = 0 ;
42469 PyObject * obj2 = 0 ;
42470 char * kwnames[] = {
42471 (char *) "self",(char *) "pos",(char *) "enable", NULL
42472 };
42473
42474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42476 if (!SWIG_IsOK(res1)) {
42477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42478 }
42479 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42480 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42481 if (!SWIG_IsOK(ecode2)) {
42482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42483 }
42484 arg2 = static_cast< size_t >(val2);
42485 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42486 if (!SWIG_IsOK(ecode3)) {
42487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42488 }
42489 arg3 = static_cast< bool >(val3);
42490 {
42491 PyThreadState* __tstate = wxPyBeginAllowThreads();
42492 (arg1)->EnableTop(arg2,arg3);
42493 wxPyEndAllowThreads(__tstate);
42494 if (PyErr_Occurred()) SWIG_fail;
42495 }
42496 resultobj = SWIG_Py_Void();
42497 return resultobj;
42498 fail:
42499 return NULL;
42500 }
42501
42502
42503 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42504 PyObject *resultobj = 0;
42505 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42506 size_t arg2 ;
42507 bool result;
42508 void *argp1 = 0 ;
42509 int res1 = 0 ;
42510 size_t val2 ;
42511 int ecode2 = 0 ;
42512 PyObject * obj0 = 0 ;
42513 PyObject * obj1 = 0 ;
42514 char * kwnames[] = {
42515 (char *) "self",(char *) "pos", NULL
42516 };
42517
42518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42520 if (!SWIG_IsOK(res1)) {
42521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42522 }
42523 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42524 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42525 if (!SWIG_IsOK(ecode2)) {
42526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42527 }
42528 arg2 = static_cast< size_t >(val2);
42529 {
42530 PyThreadState* __tstate = wxPyBeginAllowThreads();
42531 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42532 wxPyEndAllowThreads(__tstate);
42533 if (PyErr_Occurred()) SWIG_fail;
42534 }
42535 {
42536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42537 }
42538 return resultobj;
42539 fail:
42540 return NULL;
42541 }
42542
42543
42544 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42545 PyObject *resultobj = 0;
42546 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42547 size_t arg2 ;
42548 wxString *arg3 = 0 ;
42549 void *argp1 = 0 ;
42550 int res1 = 0 ;
42551 size_t val2 ;
42552 int ecode2 = 0 ;
42553 bool temp3 = false ;
42554 PyObject * obj0 = 0 ;
42555 PyObject * obj1 = 0 ;
42556 PyObject * obj2 = 0 ;
42557 char * kwnames[] = {
42558 (char *) "self",(char *) "pos",(char *) "label", NULL
42559 };
42560
42561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42563 if (!SWIG_IsOK(res1)) {
42564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42565 }
42566 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42567 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42568 if (!SWIG_IsOK(ecode2)) {
42569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42570 }
42571 arg2 = static_cast< size_t >(val2);
42572 {
42573 arg3 = wxString_in_helper(obj2);
42574 if (arg3 == NULL) SWIG_fail;
42575 temp3 = true;
42576 }
42577 {
42578 PyThreadState* __tstate = wxPyBeginAllowThreads();
42579 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42580 wxPyEndAllowThreads(__tstate);
42581 if (PyErr_Occurred()) SWIG_fail;
42582 }
42583 resultobj = SWIG_Py_Void();
42584 {
42585 if (temp3)
42586 delete arg3;
42587 }
42588 return resultobj;
42589 fail:
42590 {
42591 if (temp3)
42592 delete arg3;
42593 }
42594 return NULL;
42595 }
42596
42597
42598 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42599 PyObject *resultobj = 0;
42600 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42601 size_t arg2 ;
42602 wxString result;
42603 void *argp1 = 0 ;
42604 int res1 = 0 ;
42605 size_t val2 ;
42606 int ecode2 = 0 ;
42607 PyObject * obj0 = 0 ;
42608 PyObject * obj1 = 0 ;
42609 char * kwnames[] = {
42610 (char *) "self",(char *) "pos", NULL
42611 };
42612
42613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42615 if (!SWIG_IsOK(res1)) {
42616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42617 }
42618 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42619 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42620 if (!SWIG_IsOK(ecode2)) {
42621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42622 }
42623 arg2 = static_cast< size_t >(val2);
42624 {
42625 PyThreadState* __tstate = wxPyBeginAllowThreads();
42626 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42627 wxPyEndAllowThreads(__tstate);
42628 if (PyErr_Occurred()) SWIG_fail;
42629 }
42630 {
42631 #if wxUSE_UNICODE
42632 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42633 #else
42634 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42635 #endif
42636 }
42637 return resultobj;
42638 fail:
42639 return NULL;
42640 }
42641
42642
42643 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42644 PyObject *resultobj = 0;
42645 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42646 wxString *arg2 = 0 ;
42647 wxString *arg3 = 0 ;
42648 int result;
42649 void *argp1 = 0 ;
42650 int res1 = 0 ;
42651 bool temp2 = false ;
42652 bool temp3 = false ;
42653 PyObject * obj0 = 0 ;
42654 PyObject * obj1 = 0 ;
42655 PyObject * obj2 = 0 ;
42656 char * kwnames[] = {
42657 (char *) "self",(char *) "menu",(char *) "item", NULL
42658 };
42659
42660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42662 if (!SWIG_IsOK(res1)) {
42663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42664 }
42665 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42666 {
42667 arg2 = wxString_in_helper(obj1);
42668 if (arg2 == NULL) SWIG_fail;
42669 temp2 = true;
42670 }
42671 {
42672 arg3 = wxString_in_helper(obj2);
42673 if (arg3 == NULL) SWIG_fail;
42674 temp3 = true;
42675 }
42676 {
42677 PyThreadState* __tstate = wxPyBeginAllowThreads();
42678 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42679 wxPyEndAllowThreads(__tstate);
42680 if (PyErr_Occurred()) SWIG_fail;
42681 }
42682 resultobj = SWIG_From_int(static_cast< int >(result));
42683 {
42684 if (temp2)
42685 delete arg2;
42686 }
42687 {
42688 if (temp3)
42689 delete arg3;
42690 }
42691 return resultobj;
42692 fail:
42693 {
42694 if (temp2)
42695 delete arg2;
42696 }
42697 {
42698 if (temp3)
42699 delete arg3;
42700 }
42701 return NULL;
42702 }
42703
42704
42705 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42706 PyObject *resultobj = 0;
42707 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42708 int arg2 ;
42709 wxMenuItem *result = 0 ;
42710 void *argp1 = 0 ;
42711 int res1 = 0 ;
42712 int val2 ;
42713 int ecode2 = 0 ;
42714 PyObject * obj0 = 0 ;
42715 PyObject * obj1 = 0 ;
42716 char * kwnames[] = {
42717 (char *) "self",(char *) "id", NULL
42718 };
42719
42720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42722 if (!SWIG_IsOK(res1)) {
42723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42724 }
42725 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42726 ecode2 = SWIG_AsVal_int(obj1, &val2);
42727 if (!SWIG_IsOK(ecode2)) {
42728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42729 }
42730 arg2 = static_cast< int >(val2);
42731 {
42732 PyThreadState* __tstate = wxPyBeginAllowThreads();
42733 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42734 wxPyEndAllowThreads(__tstate);
42735 if (PyErr_Occurred()) SWIG_fail;
42736 }
42737 {
42738 resultobj = wxPyMake_wxObject(result, (bool)0);
42739 }
42740 return resultobj;
42741 fail:
42742 return NULL;
42743 }
42744
42745
42746 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42747 PyObject *resultobj = 0;
42748 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42749 wxString *arg2 = 0 ;
42750 int result;
42751 void *argp1 = 0 ;
42752 int res1 = 0 ;
42753 bool temp2 = false ;
42754 PyObject * obj0 = 0 ;
42755 PyObject * obj1 = 0 ;
42756 char * kwnames[] = {
42757 (char *) "self",(char *) "title", NULL
42758 };
42759
42760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42762 if (!SWIG_IsOK(res1)) {
42763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42764 }
42765 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42766 {
42767 arg2 = wxString_in_helper(obj1);
42768 if (arg2 == NULL) SWIG_fail;
42769 temp2 = true;
42770 }
42771 {
42772 PyThreadState* __tstate = wxPyBeginAllowThreads();
42773 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42774 wxPyEndAllowThreads(__tstate);
42775 if (PyErr_Occurred()) SWIG_fail;
42776 }
42777 resultobj = SWIG_From_int(static_cast< int >(result));
42778 {
42779 if (temp2)
42780 delete arg2;
42781 }
42782 return resultobj;
42783 fail:
42784 {
42785 if (temp2)
42786 delete arg2;
42787 }
42788 return NULL;
42789 }
42790
42791
42792 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42793 PyObject *resultobj = 0;
42794 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42795 int arg2 ;
42796 bool arg3 ;
42797 void *argp1 = 0 ;
42798 int res1 = 0 ;
42799 int val2 ;
42800 int ecode2 = 0 ;
42801 bool val3 ;
42802 int ecode3 = 0 ;
42803 PyObject * obj0 = 0 ;
42804 PyObject * obj1 = 0 ;
42805 PyObject * obj2 = 0 ;
42806 char * kwnames[] = {
42807 (char *) "self",(char *) "id",(char *) "enable", NULL
42808 };
42809
42810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42812 if (!SWIG_IsOK(res1)) {
42813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42814 }
42815 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42816 ecode2 = SWIG_AsVal_int(obj1, &val2);
42817 if (!SWIG_IsOK(ecode2)) {
42818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42819 }
42820 arg2 = static_cast< int >(val2);
42821 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42822 if (!SWIG_IsOK(ecode3)) {
42823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42824 }
42825 arg3 = static_cast< bool >(val3);
42826 {
42827 PyThreadState* __tstate = wxPyBeginAllowThreads();
42828 (arg1)->Enable(arg2,arg3);
42829 wxPyEndAllowThreads(__tstate);
42830 if (PyErr_Occurred()) SWIG_fail;
42831 }
42832 resultobj = SWIG_Py_Void();
42833 return resultobj;
42834 fail:
42835 return NULL;
42836 }
42837
42838
42839 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42840 PyObject *resultobj = 0;
42841 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42842 int arg2 ;
42843 bool arg3 ;
42844 void *argp1 = 0 ;
42845 int res1 = 0 ;
42846 int val2 ;
42847 int ecode2 = 0 ;
42848 bool val3 ;
42849 int ecode3 = 0 ;
42850 PyObject * obj0 = 0 ;
42851 PyObject * obj1 = 0 ;
42852 PyObject * obj2 = 0 ;
42853 char * kwnames[] = {
42854 (char *) "self",(char *) "id",(char *) "check", NULL
42855 };
42856
42857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42859 if (!SWIG_IsOK(res1)) {
42860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42861 }
42862 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42863 ecode2 = SWIG_AsVal_int(obj1, &val2);
42864 if (!SWIG_IsOK(ecode2)) {
42865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42866 }
42867 arg2 = static_cast< int >(val2);
42868 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42869 if (!SWIG_IsOK(ecode3)) {
42870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
42871 }
42872 arg3 = static_cast< bool >(val3);
42873 {
42874 PyThreadState* __tstate = wxPyBeginAllowThreads();
42875 (arg1)->Check(arg2,arg3);
42876 wxPyEndAllowThreads(__tstate);
42877 if (PyErr_Occurred()) SWIG_fail;
42878 }
42879 resultobj = SWIG_Py_Void();
42880 return resultobj;
42881 fail:
42882 return NULL;
42883 }
42884
42885
42886 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42887 PyObject *resultobj = 0;
42888 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42889 int arg2 ;
42890 bool result;
42891 void *argp1 = 0 ;
42892 int res1 = 0 ;
42893 int val2 ;
42894 int ecode2 = 0 ;
42895 PyObject * obj0 = 0 ;
42896 PyObject * obj1 = 0 ;
42897 char * kwnames[] = {
42898 (char *) "self",(char *) "id", NULL
42899 };
42900
42901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42903 if (!SWIG_IsOK(res1)) {
42904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42905 }
42906 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42907 ecode2 = SWIG_AsVal_int(obj1, &val2);
42908 if (!SWIG_IsOK(ecode2)) {
42909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42910 }
42911 arg2 = static_cast< int >(val2);
42912 {
42913 PyThreadState* __tstate = wxPyBeginAllowThreads();
42914 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42915 wxPyEndAllowThreads(__tstate);
42916 if (PyErr_Occurred()) SWIG_fail;
42917 }
42918 {
42919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42920 }
42921 return resultobj;
42922 fail:
42923 return NULL;
42924 }
42925
42926
42927 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42928 PyObject *resultobj = 0;
42929 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42930 int arg2 ;
42931 bool result;
42932 void *argp1 = 0 ;
42933 int res1 = 0 ;
42934 int val2 ;
42935 int ecode2 = 0 ;
42936 PyObject * obj0 = 0 ;
42937 PyObject * obj1 = 0 ;
42938 char * kwnames[] = {
42939 (char *) "self",(char *) "id", NULL
42940 };
42941
42942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42944 if (!SWIG_IsOK(res1)) {
42945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42946 }
42947 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42948 ecode2 = SWIG_AsVal_int(obj1, &val2);
42949 if (!SWIG_IsOK(ecode2)) {
42950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42951 }
42952 arg2 = static_cast< int >(val2);
42953 {
42954 PyThreadState* __tstate = wxPyBeginAllowThreads();
42955 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42956 wxPyEndAllowThreads(__tstate);
42957 if (PyErr_Occurred()) SWIG_fail;
42958 }
42959 {
42960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42961 }
42962 return resultobj;
42963 fail:
42964 return NULL;
42965 }
42966
42967
42968 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42969 PyObject *resultobj = 0;
42970 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42971 int arg2 ;
42972 wxString *arg3 = 0 ;
42973 void *argp1 = 0 ;
42974 int res1 = 0 ;
42975 int val2 ;
42976 int ecode2 = 0 ;
42977 bool temp3 = false ;
42978 PyObject * obj0 = 0 ;
42979 PyObject * obj1 = 0 ;
42980 PyObject * obj2 = 0 ;
42981 char * kwnames[] = {
42982 (char *) "self",(char *) "id",(char *) "label", NULL
42983 };
42984
42985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42987 if (!SWIG_IsOK(res1)) {
42988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42989 }
42990 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42991 ecode2 = SWIG_AsVal_int(obj1, &val2);
42992 if (!SWIG_IsOK(ecode2)) {
42993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42994 }
42995 arg2 = static_cast< int >(val2);
42996 {
42997 arg3 = wxString_in_helper(obj2);
42998 if (arg3 == NULL) SWIG_fail;
42999 temp3 = true;
43000 }
43001 {
43002 PyThreadState* __tstate = wxPyBeginAllowThreads();
43003 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43004 wxPyEndAllowThreads(__tstate);
43005 if (PyErr_Occurred()) SWIG_fail;
43006 }
43007 resultobj = SWIG_Py_Void();
43008 {
43009 if (temp3)
43010 delete arg3;
43011 }
43012 return resultobj;
43013 fail:
43014 {
43015 if (temp3)
43016 delete arg3;
43017 }
43018 return NULL;
43019 }
43020
43021
43022 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43023 PyObject *resultobj = 0;
43024 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43025 int arg2 ;
43026 wxString result;
43027 void *argp1 = 0 ;
43028 int res1 = 0 ;
43029 int val2 ;
43030 int ecode2 = 0 ;
43031 PyObject * obj0 = 0 ;
43032 PyObject * obj1 = 0 ;
43033 char * kwnames[] = {
43034 (char *) "self",(char *) "id", NULL
43035 };
43036
43037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43039 if (!SWIG_IsOK(res1)) {
43040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43041 }
43042 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43043 ecode2 = SWIG_AsVal_int(obj1, &val2);
43044 if (!SWIG_IsOK(ecode2)) {
43045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
43046 }
43047 arg2 = static_cast< int >(val2);
43048 {
43049 PyThreadState* __tstate = wxPyBeginAllowThreads();
43050 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
43051 wxPyEndAllowThreads(__tstate);
43052 if (PyErr_Occurred()) SWIG_fail;
43053 }
43054 {
43055 #if wxUSE_UNICODE
43056 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43057 #else
43058 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43059 #endif
43060 }
43061 return resultobj;
43062 fail:
43063 return NULL;
43064 }
43065
43066
43067 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43068 PyObject *resultobj = 0;
43069 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43070 int arg2 ;
43071 wxString *arg3 = 0 ;
43072 void *argp1 = 0 ;
43073 int res1 = 0 ;
43074 int val2 ;
43075 int ecode2 = 0 ;
43076 bool temp3 = false ;
43077 PyObject * obj0 = 0 ;
43078 PyObject * obj1 = 0 ;
43079 PyObject * obj2 = 0 ;
43080 char * kwnames[] = {
43081 (char *) "self",(char *) "id",(char *) "helpString", NULL
43082 };
43083
43084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43086 if (!SWIG_IsOK(res1)) {
43087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43088 }
43089 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43090 ecode2 = SWIG_AsVal_int(obj1, &val2);
43091 if (!SWIG_IsOK(ecode2)) {
43092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43093 }
43094 arg2 = static_cast< int >(val2);
43095 {
43096 arg3 = wxString_in_helper(obj2);
43097 if (arg3 == NULL) SWIG_fail;
43098 temp3 = true;
43099 }
43100 {
43101 PyThreadState* __tstate = wxPyBeginAllowThreads();
43102 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43103 wxPyEndAllowThreads(__tstate);
43104 if (PyErr_Occurred()) SWIG_fail;
43105 }
43106 resultobj = SWIG_Py_Void();
43107 {
43108 if (temp3)
43109 delete arg3;
43110 }
43111 return resultobj;
43112 fail:
43113 {
43114 if (temp3)
43115 delete arg3;
43116 }
43117 return NULL;
43118 }
43119
43120
43121 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43122 PyObject *resultobj = 0;
43123 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43124 int arg2 ;
43125 wxString result;
43126 void *argp1 = 0 ;
43127 int res1 = 0 ;
43128 int val2 ;
43129 int ecode2 = 0 ;
43130 PyObject * obj0 = 0 ;
43131 PyObject * obj1 = 0 ;
43132 char * kwnames[] = {
43133 (char *) "self",(char *) "id", NULL
43134 };
43135
43136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43138 if (!SWIG_IsOK(res1)) {
43139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43140 }
43141 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43142 ecode2 = SWIG_AsVal_int(obj1, &val2);
43143 if (!SWIG_IsOK(ecode2)) {
43144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43145 }
43146 arg2 = static_cast< int >(val2);
43147 {
43148 PyThreadState* __tstate = wxPyBeginAllowThreads();
43149 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
43150 wxPyEndAllowThreads(__tstate);
43151 if (PyErr_Occurred()) SWIG_fail;
43152 }
43153 {
43154 #if wxUSE_UNICODE
43155 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43156 #else
43157 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43158 #endif
43159 }
43160 return resultobj;
43161 fail:
43162 return NULL;
43163 }
43164
43165
43166 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43167 PyObject *resultobj = 0;
43168 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43169 wxFrame *result = 0 ;
43170 void *argp1 = 0 ;
43171 int res1 = 0 ;
43172 PyObject *swig_obj[1] ;
43173
43174 if (!args) SWIG_fail;
43175 swig_obj[0] = args;
43176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43177 if (!SWIG_IsOK(res1)) {
43178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43179 }
43180 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43181 {
43182 PyThreadState* __tstate = wxPyBeginAllowThreads();
43183 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
43184 wxPyEndAllowThreads(__tstate);
43185 if (PyErr_Occurred()) SWIG_fail;
43186 }
43187 {
43188 resultobj = wxPyMake_wxObject(result, (bool)0);
43189 }
43190 return resultobj;
43191 fail:
43192 return NULL;
43193 }
43194
43195
43196 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43197 PyObject *resultobj = 0;
43198 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43199 bool result;
43200 void *argp1 = 0 ;
43201 int res1 = 0 ;
43202 PyObject *swig_obj[1] ;
43203
43204 if (!args) SWIG_fail;
43205 swig_obj[0] = args;
43206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43207 if (!SWIG_IsOK(res1)) {
43208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43209 }
43210 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43211 {
43212 PyThreadState* __tstate = wxPyBeginAllowThreads();
43213 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
43214 wxPyEndAllowThreads(__tstate);
43215 if (PyErr_Occurred()) SWIG_fail;
43216 }
43217 {
43218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43219 }
43220 return resultobj;
43221 fail:
43222 return NULL;
43223 }
43224
43225
43226 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43227 PyObject *resultobj = 0;
43228 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43229 wxFrame *arg2 = (wxFrame *) 0 ;
43230 void *argp1 = 0 ;
43231 int res1 = 0 ;
43232 void *argp2 = 0 ;
43233 int res2 = 0 ;
43234 PyObject * obj0 = 0 ;
43235 PyObject * obj1 = 0 ;
43236 char * kwnames[] = {
43237 (char *) "self",(char *) "frame", NULL
43238 };
43239
43240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) 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_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43244 }
43245 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43246 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
43247 if (!SWIG_IsOK(res2)) {
43248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
43249 }
43250 arg2 = reinterpret_cast< wxFrame * >(argp2);
43251 {
43252 PyThreadState* __tstate = wxPyBeginAllowThreads();
43253 (arg1)->Attach(arg2);
43254 wxPyEndAllowThreads(__tstate);
43255 if (PyErr_Occurred()) SWIG_fail;
43256 }
43257 resultobj = SWIG_Py_Void();
43258 return resultobj;
43259 fail:
43260 return NULL;
43261 }
43262
43263
43264 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43265 PyObject *resultobj = 0;
43266 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43267 void *argp1 = 0 ;
43268 int res1 = 0 ;
43269 PyObject *swig_obj[1] ;
43270
43271 if (!args) SWIG_fail;
43272 swig_obj[0] = args;
43273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43274 if (!SWIG_IsOK(res1)) {
43275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43276 }
43277 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43278 {
43279 PyThreadState* __tstate = wxPyBeginAllowThreads();
43280 (arg1)->Detach();
43281 wxPyEndAllowThreads(__tstate);
43282 if (PyErr_Occurred()) SWIG_fail;
43283 }
43284 resultobj = SWIG_Py_Void();
43285 return resultobj;
43286 fail:
43287 return NULL;
43288 }
43289
43290
43291 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43292 PyObject *resultobj = 0;
43293 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43294 void *argp1 = 0 ;
43295 int res1 = 0 ;
43296 PyObject *swig_obj[1] ;
43297
43298 if (!args) SWIG_fail;
43299 swig_obj[0] = args;
43300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43301 if (!SWIG_IsOK(res1)) {
43302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43303 }
43304 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43305 {
43306 PyThreadState* __tstate = wxPyBeginAllowThreads();
43307 (arg1)->UpdateMenus();
43308 wxPyEndAllowThreads(__tstate);
43309 if (PyErr_Occurred()) SWIG_fail;
43310 }
43311 resultobj = SWIG_Py_Void();
43312 return resultobj;
43313 fail:
43314 return NULL;
43315 }
43316
43317
43318 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43319 PyObject *resultobj = 0;
43320 bool arg1 ;
43321 bool val1 ;
43322 int ecode1 = 0 ;
43323 PyObject * obj0 = 0 ;
43324 char * kwnames[] = {
43325 (char *) "enable", NULL
43326 };
43327
43328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
43329 ecode1 = SWIG_AsVal_bool(obj0, &val1);
43330 if (!SWIG_IsOK(ecode1)) {
43331 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
43332 }
43333 arg1 = static_cast< bool >(val1);
43334 {
43335 PyThreadState* __tstate = wxPyBeginAllowThreads();
43336 wxMenuBar_SetAutoWindowMenu(arg1);
43337 wxPyEndAllowThreads(__tstate);
43338 if (PyErr_Occurred()) SWIG_fail;
43339 }
43340 resultobj = SWIG_Py_Void();
43341 return resultobj;
43342 fail:
43343 return NULL;
43344 }
43345
43346
43347 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43348 PyObject *resultobj = 0;
43349 bool result;
43350
43351 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
43352 {
43353 PyThreadState* __tstate = wxPyBeginAllowThreads();
43354 result = (bool)wxMenuBar_GetAutoWindowMenu();
43355 wxPyEndAllowThreads(__tstate);
43356 if (PyErr_Occurred()) SWIG_fail;
43357 }
43358 {
43359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43360 }
43361 return resultobj;
43362 fail:
43363 return NULL;
43364 }
43365
43366
43367 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43368 PyObject *obj;
43369 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43370 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
43371 return SWIG_Py_Void();
43372 }
43373
43374 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43375 return SWIG_Python_InitShadowInstance(args);
43376 }
43377
43378 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43379 PyObject *resultobj = 0;
43380 wxMenu *arg1 = (wxMenu *) NULL ;
43381 int arg2 = (int) wxID_ANY ;
43382 wxString const &arg3_defvalue = wxPyEmptyString ;
43383 wxString *arg3 = (wxString *) &arg3_defvalue ;
43384 wxString const &arg4_defvalue = wxPyEmptyString ;
43385 wxString *arg4 = (wxString *) &arg4_defvalue ;
43386 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43387 wxMenu *arg6 = (wxMenu *) NULL ;
43388 wxMenuItem *result = 0 ;
43389 void *argp1 = 0 ;
43390 int res1 = 0 ;
43391 int val2 ;
43392 int ecode2 = 0 ;
43393 bool temp3 = false ;
43394 bool temp4 = false ;
43395 int val5 ;
43396 int ecode5 = 0 ;
43397 void *argp6 = 0 ;
43398 int res6 = 0 ;
43399 PyObject * obj0 = 0 ;
43400 PyObject * obj1 = 0 ;
43401 PyObject * obj2 = 0 ;
43402 PyObject * obj3 = 0 ;
43403 PyObject * obj4 = 0 ;
43404 PyObject * obj5 = 0 ;
43405 char * kwnames[] = {
43406 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
43407 };
43408
43409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43410 if (obj0) {
43411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43412 if (!SWIG_IsOK(res1)) {
43413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43414 }
43415 arg1 = reinterpret_cast< wxMenu * >(argp1);
43416 }
43417 if (obj1) {
43418 ecode2 = SWIG_AsVal_int(obj1, &val2);
43419 if (!SWIG_IsOK(ecode2)) {
43420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
43421 }
43422 arg2 = static_cast< int >(val2);
43423 }
43424 if (obj2) {
43425 {
43426 arg3 = wxString_in_helper(obj2);
43427 if (arg3 == NULL) SWIG_fail;
43428 temp3 = true;
43429 }
43430 }
43431 if (obj3) {
43432 {
43433 arg4 = wxString_in_helper(obj3);
43434 if (arg4 == NULL) SWIG_fail;
43435 temp4 = true;
43436 }
43437 }
43438 if (obj4) {
43439 ecode5 = SWIG_AsVal_int(obj4, &val5);
43440 if (!SWIG_IsOK(ecode5)) {
43441 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
43442 }
43443 arg5 = static_cast< wxItemKind >(val5);
43444 }
43445 if (obj5) {
43446 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
43447 if (!SWIG_IsOK(res6)) {
43448 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
43449 }
43450 arg6 = reinterpret_cast< wxMenu * >(argp6);
43451 }
43452 {
43453 PyThreadState* __tstate = wxPyBeginAllowThreads();
43454 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
43455 wxPyEndAllowThreads(__tstate);
43456 if (PyErr_Occurred()) SWIG_fail;
43457 }
43458 {
43459 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
43460 }
43461 {
43462 if (temp3)
43463 delete arg3;
43464 }
43465 {
43466 if (temp4)
43467 delete arg4;
43468 }
43469 return resultobj;
43470 fail:
43471 {
43472 if (temp3)
43473 delete arg3;
43474 }
43475 {
43476 if (temp4)
43477 delete arg4;
43478 }
43479 return NULL;
43480 }
43481
43482
43483 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43484 PyObject *resultobj = 0;
43485 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43486 void *argp1 = 0 ;
43487 int res1 = 0 ;
43488 PyObject *swig_obj[1] ;
43489
43490 if (!args) SWIG_fail;
43491 swig_obj[0] = args;
43492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43493 if (!SWIG_IsOK(res1)) {
43494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43495 }
43496 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43497 {
43498 PyThreadState* __tstate = wxPyBeginAllowThreads();
43499 delete arg1;
43500
43501 wxPyEndAllowThreads(__tstate);
43502 if (PyErr_Occurred()) SWIG_fail;
43503 }
43504 resultobj = SWIG_Py_Void();
43505 return resultobj;
43506 fail:
43507 return NULL;
43508 }
43509
43510
43511 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43512 PyObject *resultobj = 0;
43513 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43514 wxMenu *result = 0 ;
43515 void *argp1 = 0 ;
43516 int res1 = 0 ;
43517 PyObject *swig_obj[1] ;
43518
43519 if (!args) SWIG_fail;
43520 swig_obj[0] = args;
43521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43522 if (!SWIG_IsOK(res1)) {
43523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43524 }
43525 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43526 {
43527 PyThreadState* __tstate = wxPyBeginAllowThreads();
43528 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43529 wxPyEndAllowThreads(__tstate);
43530 if (PyErr_Occurred()) SWIG_fail;
43531 }
43532 {
43533 resultobj = wxPyMake_wxObject(result, 0);
43534 }
43535 return resultobj;
43536 fail:
43537 return NULL;
43538 }
43539
43540
43541 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43542 PyObject *resultobj = 0;
43543 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43544 wxMenu *arg2 = (wxMenu *) 0 ;
43545 void *argp1 = 0 ;
43546 int res1 = 0 ;
43547 void *argp2 = 0 ;
43548 int res2 = 0 ;
43549 PyObject * obj0 = 0 ;
43550 PyObject * obj1 = 0 ;
43551 char * kwnames[] = {
43552 (char *) "self",(char *) "menu", NULL
43553 };
43554
43555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43557 if (!SWIG_IsOK(res1)) {
43558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43559 }
43560 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43561 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43562 if (!SWIG_IsOK(res2)) {
43563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43564 }
43565 arg2 = reinterpret_cast< wxMenu * >(argp2);
43566 {
43567 PyThreadState* __tstate = wxPyBeginAllowThreads();
43568 (arg1)->SetMenu(arg2);
43569 wxPyEndAllowThreads(__tstate);
43570 if (PyErr_Occurred()) SWIG_fail;
43571 }
43572 resultobj = SWIG_Py_Void();
43573 return resultobj;
43574 fail:
43575 return NULL;
43576 }
43577
43578
43579 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43580 PyObject *resultobj = 0;
43581 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43582 int arg2 ;
43583 void *argp1 = 0 ;
43584 int res1 = 0 ;
43585 int val2 ;
43586 int ecode2 = 0 ;
43587 PyObject * obj0 = 0 ;
43588 PyObject * obj1 = 0 ;
43589 char * kwnames[] = {
43590 (char *) "self",(char *) "id", NULL
43591 };
43592
43593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43595 if (!SWIG_IsOK(res1)) {
43596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43597 }
43598 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43599 ecode2 = SWIG_AsVal_int(obj1, &val2);
43600 if (!SWIG_IsOK(ecode2)) {
43601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43602 }
43603 arg2 = static_cast< int >(val2);
43604 {
43605 PyThreadState* __tstate = wxPyBeginAllowThreads();
43606 (arg1)->SetId(arg2);
43607 wxPyEndAllowThreads(__tstate);
43608 if (PyErr_Occurred()) SWIG_fail;
43609 }
43610 resultobj = SWIG_Py_Void();
43611 return resultobj;
43612 fail:
43613 return NULL;
43614 }
43615
43616
43617 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43618 PyObject *resultobj = 0;
43619 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43620 int result;
43621 void *argp1 = 0 ;
43622 int res1 = 0 ;
43623 PyObject *swig_obj[1] ;
43624
43625 if (!args) SWIG_fail;
43626 swig_obj[0] = args;
43627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43628 if (!SWIG_IsOK(res1)) {
43629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43630 }
43631 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43632 {
43633 PyThreadState* __tstate = wxPyBeginAllowThreads();
43634 result = (int)((wxMenuItem const *)arg1)->GetId();
43635 wxPyEndAllowThreads(__tstate);
43636 if (PyErr_Occurred()) SWIG_fail;
43637 }
43638 resultobj = SWIG_From_int(static_cast< int >(result));
43639 return resultobj;
43640 fail:
43641 return NULL;
43642 }
43643
43644
43645 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43646 PyObject *resultobj = 0;
43647 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43648 bool result;
43649 void *argp1 = 0 ;
43650 int res1 = 0 ;
43651 PyObject *swig_obj[1] ;
43652
43653 if (!args) SWIG_fail;
43654 swig_obj[0] = args;
43655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43656 if (!SWIG_IsOK(res1)) {
43657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43658 }
43659 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43660 {
43661 PyThreadState* __tstate = wxPyBeginAllowThreads();
43662 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43663 wxPyEndAllowThreads(__tstate);
43664 if (PyErr_Occurred()) SWIG_fail;
43665 }
43666 {
43667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43668 }
43669 return resultobj;
43670 fail:
43671 return NULL;
43672 }
43673
43674
43675 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43676 PyObject *resultobj = 0;
43677 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43678 wxString *arg2 = 0 ;
43679 void *argp1 = 0 ;
43680 int res1 = 0 ;
43681 bool temp2 = false ;
43682 PyObject * obj0 = 0 ;
43683 PyObject * obj1 = 0 ;
43684 char * kwnames[] = {
43685 (char *) "self",(char *) "str", NULL
43686 };
43687
43688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43690 if (!SWIG_IsOK(res1)) {
43691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43692 }
43693 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43694 {
43695 arg2 = wxString_in_helper(obj1);
43696 if (arg2 == NULL) SWIG_fail;
43697 temp2 = true;
43698 }
43699 {
43700 PyThreadState* __tstate = wxPyBeginAllowThreads();
43701 (arg1)->SetText((wxString const &)*arg2);
43702 wxPyEndAllowThreads(__tstate);
43703 if (PyErr_Occurred()) SWIG_fail;
43704 }
43705 resultobj = SWIG_Py_Void();
43706 {
43707 if (temp2)
43708 delete arg2;
43709 }
43710 return resultobj;
43711 fail:
43712 {
43713 if (temp2)
43714 delete arg2;
43715 }
43716 return NULL;
43717 }
43718
43719
43720 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43721 PyObject *resultobj = 0;
43722 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43723 wxString result;
43724 void *argp1 = 0 ;
43725 int res1 = 0 ;
43726 PyObject *swig_obj[1] ;
43727
43728 if (!args) SWIG_fail;
43729 swig_obj[0] = args;
43730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43731 if (!SWIG_IsOK(res1)) {
43732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43733 }
43734 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43735 {
43736 PyThreadState* __tstate = wxPyBeginAllowThreads();
43737 result = ((wxMenuItem const *)arg1)->GetLabel();
43738 wxPyEndAllowThreads(__tstate);
43739 if (PyErr_Occurred()) SWIG_fail;
43740 }
43741 {
43742 #if wxUSE_UNICODE
43743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43744 #else
43745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43746 #endif
43747 }
43748 return resultobj;
43749 fail:
43750 return NULL;
43751 }
43752
43753
43754 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43755 PyObject *resultobj = 0;
43756 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43757 wxString *result = 0 ;
43758 void *argp1 = 0 ;
43759 int res1 = 0 ;
43760 PyObject *swig_obj[1] ;
43761
43762 if (!args) SWIG_fail;
43763 swig_obj[0] = args;
43764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43765 if (!SWIG_IsOK(res1)) {
43766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43767 }
43768 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43769 {
43770 PyThreadState* __tstate = wxPyBeginAllowThreads();
43771 {
43772 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43773 result = (wxString *) &_result_ref;
43774 }
43775 wxPyEndAllowThreads(__tstate);
43776 if (PyErr_Occurred()) SWIG_fail;
43777 }
43778 {
43779 #if wxUSE_UNICODE
43780 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43781 #else
43782 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43783 #endif
43784 }
43785 return resultobj;
43786 fail:
43787 return NULL;
43788 }
43789
43790
43791 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43792 PyObject *resultobj = 0;
43793 wxString *arg1 = 0 ;
43794 wxString result;
43795 bool temp1 = false ;
43796 PyObject * obj0 = 0 ;
43797 char * kwnames[] = {
43798 (char *) "text", NULL
43799 };
43800
43801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43802 {
43803 arg1 = wxString_in_helper(obj0);
43804 if (arg1 == NULL) SWIG_fail;
43805 temp1 = true;
43806 }
43807 {
43808 PyThreadState* __tstate = wxPyBeginAllowThreads();
43809 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43810 wxPyEndAllowThreads(__tstate);
43811 if (PyErr_Occurred()) SWIG_fail;
43812 }
43813 {
43814 #if wxUSE_UNICODE
43815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43816 #else
43817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43818 #endif
43819 }
43820 {
43821 if (temp1)
43822 delete arg1;
43823 }
43824 return resultobj;
43825 fail:
43826 {
43827 if (temp1)
43828 delete arg1;
43829 }
43830 return NULL;
43831 }
43832
43833
43834 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43835 PyObject *resultobj = 0;
43836 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43837 wxItemKind result;
43838 void *argp1 = 0 ;
43839 int res1 = 0 ;
43840 PyObject *swig_obj[1] ;
43841
43842 if (!args) SWIG_fail;
43843 swig_obj[0] = args;
43844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43845 if (!SWIG_IsOK(res1)) {
43846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43847 }
43848 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43849 {
43850 PyThreadState* __tstate = wxPyBeginAllowThreads();
43851 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43852 wxPyEndAllowThreads(__tstate);
43853 if (PyErr_Occurred()) SWIG_fail;
43854 }
43855 resultobj = SWIG_From_int(static_cast< int >(result));
43856 return resultobj;
43857 fail:
43858 return NULL;
43859 }
43860
43861
43862 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43863 PyObject *resultobj = 0;
43864 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43865 wxItemKind arg2 ;
43866 void *argp1 = 0 ;
43867 int res1 = 0 ;
43868 int val2 ;
43869 int ecode2 = 0 ;
43870 PyObject * obj0 = 0 ;
43871 PyObject * obj1 = 0 ;
43872 char * kwnames[] = {
43873 (char *) "self",(char *) "kind", NULL
43874 };
43875
43876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
43877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43878 if (!SWIG_IsOK(res1)) {
43879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43880 }
43881 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43882 ecode2 = SWIG_AsVal_int(obj1, &val2);
43883 if (!SWIG_IsOK(ecode2)) {
43884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43885 }
43886 arg2 = static_cast< wxItemKind >(val2);
43887 {
43888 PyThreadState* __tstate = wxPyBeginAllowThreads();
43889 (arg1)->SetKind(arg2);
43890 wxPyEndAllowThreads(__tstate);
43891 if (PyErr_Occurred()) SWIG_fail;
43892 }
43893 resultobj = SWIG_Py_Void();
43894 return resultobj;
43895 fail:
43896 return NULL;
43897 }
43898
43899
43900 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43901 PyObject *resultobj = 0;
43902 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43903 bool arg2 ;
43904 void *argp1 = 0 ;
43905 int res1 = 0 ;
43906 bool val2 ;
43907 int ecode2 = 0 ;
43908 PyObject * obj0 = 0 ;
43909 PyObject * obj1 = 0 ;
43910 char * kwnames[] = {
43911 (char *) "self",(char *) "checkable", NULL
43912 };
43913
43914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43916 if (!SWIG_IsOK(res1)) {
43917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43918 }
43919 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43920 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43921 if (!SWIG_IsOK(ecode2)) {
43922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43923 }
43924 arg2 = static_cast< bool >(val2);
43925 {
43926 PyThreadState* __tstate = wxPyBeginAllowThreads();
43927 (arg1)->SetCheckable(arg2);
43928 wxPyEndAllowThreads(__tstate);
43929 if (PyErr_Occurred()) SWIG_fail;
43930 }
43931 resultobj = SWIG_Py_Void();
43932 return resultobj;
43933 fail:
43934 return NULL;
43935 }
43936
43937
43938 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43939 PyObject *resultobj = 0;
43940 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43941 bool result;
43942 void *argp1 = 0 ;
43943 int res1 = 0 ;
43944 PyObject *swig_obj[1] ;
43945
43946 if (!args) SWIG_fail;
43947 swig_obj[0] = args;
43948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43949 if (!SWIG_IsOK(res1)) {
43950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43951 }
43952 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43953 {
43954 PyThreadState* __tstate = wxPyBeginAllowThreads();
43955 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43956 wxPyEndAllowThreads(__tstate);
43957 if (PyErr_Occurred()) SWIG_fail;
43958 }
43959 {
43960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43961 }
43962 return resultobj;
43963 fail:
43964 return NULL;
43965 }
43966
43967
43968 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43969 PyObject *resultobj = 0;
43970 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43971 bool result;
43972 void *argp1 = 0 ;
43973 int res1 = 0 ;
43974 PyObject *swig_obj[1] ;
43975
43976 if (!args) SWIG_fail;
43977 swig_obj[0] = args;
43978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43979 if (!SWIG_IsOK(res1)) {
43980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43981 }
43982 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43983 {
43984 PyThreadState* __tstate = wxPyBeginAllowThreads();
43985 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43986 wxPyEndAllowThreads(__tstate);
43987 if (PyErr_Occurred()) SWIG_fail;
43988 }
43989 {
43990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43991 }
43992 return resultobj;
43993 fail:
43994 return NULL;
43995 }
43996
43997
43998 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43999 PyObject *resultobj = 0;
44000 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44001 wxMenu *arg2 = (wxMenu *) 0 ;
44002 void *argp1 = 0 ;
44003 int res1 = 0 ;
44004 void *argp2 = 0 ;
44005 int res2 = 0 ;
44006 PyObject * obj0 = 0 ;
44007 PyObject * obj1 = 0 ;
44008 char * kwnames[] = {
44009 (char *) "self",(char *) "menu", NULL
44010 };
44011
44012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44014 if (!SWIG_IsOK(res1)) {
44015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44016 }
44017 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44018 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44019 if (!SWIG_IsOK(res2)) {
44020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
44021 }
44022 arg2 = reinterpret_cast< wxMenu * >(argp2);
44023 {
44024 PyThreadState* __tstate = wxPyBeginAllowThreads();
44025 (arg1)->SetSubMenu(arg2);
44026 wxPyEndAllowThreads(__tstate);
44027 if (PyErr_Occurred()) SWIG_fail;
44028 }
44029 resultobj = SWIG_Py_Void();
44030 return resultobj;
44031 fail:
44032 return NULL;
44033 }
44034
44035
44036 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44037 PyObject *resultobj = 0;
44038 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44039 wxMenu *result = 0 ;
44040 void *argp1 = 0 ;
44041 int res1 = 0 ;
44042 PyObject *swig_obj[1] ;
44043
44044 if (!args) SWIG_fail;
44045 swig_obj[0] = args;
44046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44047 if (!SWIG_IsOK(res1)) {
44048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44049 }
44050 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44051 {
44052 PyThreadState* __tstate = wxPyBeginAllowThreads();
44053 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
44054 wxPyEndAllowThreads(__tstate);
44055 if (PyErr_Occurred()) SWIG_fail;
44056 }
44057 {
44058 resultobj = wxPyMake_wxObject(result, 0);
44059 }
44060 return resultobj;
44061 fail:
44062 return NULL;
44063 }
44064
44065
44066 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44067 PyObject *resultobj = 0;
44068 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44069 bool arg2 = (bool) true ;
44070 void *argp1 = 0 ;
44071 int res1 = 0 ;
44072 bool val2 ;
44073 int ecode2 = 0 ;
44074 PyObject * obj0 = 0 ;
44075 PyObject * obj1 = 0 ;
44076 char * kwnames[] = {
44077 (char *) "self",(char *) "enable", NULL
44078 };
44079
44080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
44081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44082 if (!SWIG_IsOK(res1)) {
44083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44084 }
44085 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44086 if (obj1) {
44087 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44088 if (!SWIG_IsOK(ecode2)) {
44089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
44090 }
44091 arg2 = static_cast< bool >(val2);
44092 }
44093 {
44094 PyThreadState* __tstate = wxPyBeginAllowThreads();
44095 (arg1)->Enable(arg2);
44096 wxPyEndAllowThreads(__tstate);
44097 if (PyErr_Occurred()) SWIG_fail;
44098 }
44099 resultobj = SWIG_Py_Void();
44100 return resultobj;
44101 fail:
44102 return NULL;
44103 }
44104
44105
44106 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44107 PyObject *resultobj = 0;
44108 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44109 bool result;
44110 void *argp1 = 0 ;
44111 int res1 = 0 ;
44112 PyObject *swig_obj[1] ;
44113
44114 if (!args) SWIG_fail;
44115 swig_obj[0] = args;
44116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44117 if (!SWIG_IsOK(res1)) {
44118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44119 }
44120 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44121 {
44122 PyThreadState* __tstate = wxPyBeginAllowThreads();
44123 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
44124 wxPyEndAllowThreads(__tstate);
44125 if (PyErr_Occurred()) SWIG_fail;
44126 }
44127 {
44128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44129 }
44130 return resultobj;
44131 fail:
44132 return NULL;
44133 }
44134
44135
44136 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44137 PyObject *resultobj = 0;
44138 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44139 bool arg2 = (bool) true ;
44140 void *argp1 = 0 ;
44141 int res1 = 0 ;
44142 bool val2 ;
44143 int ecode2 = 0 ;
44144 PyObject * obj0 = 0 ;
44145 PyObject * obj1 = 0 ;
44146 char * kwnames[] = {
44147 (char *) "self",(char *) "check", NULL
44148 };
44149
44150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
44151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44152 if (!SWIG_IsOK(res1)) {
44153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44154 }
44155 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44156 if (obj1) {
44157 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44158 if (!SWIG_IsOK(ecode2)) {
44159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
44160 }
44161 arg2 = static_cast< bool >(val2);
44162 }
44163 {
44164 PyThreadState* __tstate = wxPyBeginAllowThreads();
44165 (arg1)->Check(arg2);
44166 wxPyEndAllowThreads(__tstate);
44167 if (PyErr_Occurred()) SWIG_fail;
44168 }
44169 resultobj = SWIG_Py_Void();
44170 return resultobj;
44171 fail:
44172 return NULL;
44173 }
44174
44175
44176 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44177 PyObject *resultobj = 0;
44178 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44179 bool result;
44180 void *argp1 = 0 ;
44181 int res1 = 0 ;
44182 PyObject *swig_obj[1] ;
44183
44184 if (!args) SWIG_fail;
44185 swig_obj[0] = args;
44186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44187 if (!SWIG_IsOK(res1)) {
44188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44189 }
44190 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44191 {
44192 PyThreadState* __tstate = wxPyBeginAllowThreads();
44193 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
44194 wxPyEndAllowThreads(__tstate);
44195 if (PyErr_Occurred()) SWIG_fail;
44196 }
44197 {
44198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44199 }
44200 return resultobj;
44201 fail:
44202 return NULL;
44203 }
44204
44205
44206 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44207 PyObject *resultobj = 0;
44208 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44209 void *argp1 = 0 ;
44210 int res1 = 0 ;
44211 PyObject *swig_obj[1] ;
44212
44213 if (!args) SWIG_fail;
44214 swig_obj[0] = args;
44215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44216 if (!SWIG_IsOK(res1)) {
44217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44218 }
44219 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44220 {
44221 PyThreadState* __tstate = wxPyBeginAllowThreads();
44222 (arg1)->Toggle();
44223 wxPyEndAllowThreads(__tstate);
44224 if (PyErr_Occurred()) SWIG_fail;
44225 }
44226 resultobj = SWIG_Py_Void();
44227 return resultobj;
44228 fail:
44229 return NULL;
44230 }
44231
44232
44233 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44234 PyObject *resultobj = 0;
44235 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44236 wxString *arg2 = 0 ;
44237 void *argp1 = 0 ;
44238 int res1 = 0 ;
44239 bool temp2 = false ;
44240 PyObject * obj0 = 0 ;
44241 PyObject * obj1 = 0 ;
44242 char * kwnames[] = {
44243 (char *) "self",(char *) "str", NULL
44244 };
44245
44246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
44247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44248 if (!SWIG_IsOK(res1)) {
44249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44250 }
44251 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44252 {
44253 arg2 = wxString_in_helper(obj1);
44254 if (arg2 == NULL) SWIG_fail;
44255 temp2 = true;
44256 }
44257 {
44258 PyThreadState* __tstate = wxPyBeginAllowThreads();
44259 (arg1)->SetHelp((wxString const &)*arg2);
44260 wxPyEndAllowThreads(__tstate);
44261 if (PyErr_Occurred()) SWIG_fail;
44262 }
44263 resultobj = SWIG_Py_Void();
44264 {
44265 if (temp2)
44266 delete arg2;
44267 }
44268 return resultobj;
44269 fail:
44270 {
44271 if (temp2)
44272 delete arg2;
44273 }
44274 return NULL;
44275 }
44276
44277
44278 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44279 PyObject *resultobj = 0;
44280 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44281 wxString *result = 0 ;
44282 void *argp1 = 0 ;
44283 int res1 = 0 ;
44284 PyObject *swig_obj[1] ;
44285
44286 if (!args) SWIG_fail;
44287 swig_obj[0] = args;
44288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44289 if (!SWIG_IsOK(res1)) {
44290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44291 }
44292 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44293 {
44294 PyThreadState* __tstate = wxPyBeginAllowThreads();
44295 {
44296 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
44297 result = (wxString *) &_result_ref;
44298 }
44299 wxPyEndAllowThreads(__tstate);
44300 if (PyErr_Occurred()) SWIG_fail;
44301 }
44302 {
44303 #if wxUSE_UNICODE
44304 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
44305 #else
44306 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
44307 #endif
44308 }
44309 return resultobj;
44310 fail:
44311 return NULL;
44312 }
44313
44314
44315 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44316 PyObject *resultobj = 0;
44317 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44318 wxAcceleratorEntry *result = 0 ;
44319 void *argp1 = 0 ;
44320 int res1 = 0 ;
44321 PyObject *swig_obj[1] ;
44322
44323 if (!args) SWIG_fail;
44324 swig_obj[0] = args;
44325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44326 if (!SWIG_IsOK(res1)) {
44327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44328 }
44329 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44330 {
44331 PyThreadState* __tstate = wxPyBeginAllowThreads();
44332 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
44333 wxPyEndAllowThreads(__tstate);
44334 if (PyErr_Occurred()) SWIG_fail;
44335 }
44336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44337 return resultobj;
44338 fail:
44339 return NULL;
44340 }
44341
44342
44343 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44344 PyObject *resultobj = 0;
44345 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44346 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
44347 void *argp1 = 0 ;
44348 int res1 = 0 ;
44349 void *argp2 = 0 ;
44350 int res2 = 0 ;
44351 PyObject * obj0 = 0 ;
44352 PyObject * obj1 = 0 ;
44353 char * kwnames[] = {
44354 (char *) "self",(char *) "accel", NULL
44355 };
44356
44357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
44358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44359 if (!SWIG_IsOK(res1)) {
44360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44361 }
44362 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44363 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44364 if (!SWIG_IsOK(res2)) {
44365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
44366 }
44367 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
44368 {
44369 PyThreadState* __tstate = wxPyBeginAllowThreads();
44370 (arg1)->SetAccel(arg2);
44371 wxPyEndAllowThreads(__tstate);
44372 if (PyErr_Occurred()) SWIG_fail;
44373 }
44374 resultobj = SWIG_Py_Void();
44375 return resultobj;
44376 fail:
44377 return NULL;
44378 }
44379
44380
44381 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44382 PyObject *resultobj = 0;
44383 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44384 wxBitmap *arg2 = 0 ;
44385 void *argp1 = 0 ;
44386 int res1 = 0 ;
44387 void *argp2 = 0 ;
44388 int res2 = 0 ;
44389 PyObject * obj0 = 0 ;
44390 PyObject * obj1 = 0 ;
44391 char * kwnames[] = {
44392 (char *) "self",(char *) "bitmap", NULL
44393 };
44394
44395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44397 if (!SWIG_IsOK(res1)) {
44398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44399 }
44400 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44401 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44402 if (!SWIG_IsOK(res2)) {
44403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44404 }
44405 if (!argp2) {
44406 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44407 }
44408 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44409 {
44410 PyThreadState* __tstate = wxPyBeginAllowThreads();
44411 (arg1)->SetBitmap((wxBitmap const &)*arg2);
44412 wxPyEndAllowThreads(__tstate);
44413 if (PyErr_Occurred()) SWIG_fail;
44414 }
44415 resultobj = SWIG_Py_Void();
44416 return resultobj;
44417 fail:
44418 return NULL;
44419 }
44420
44421
44422 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44423 PyObject *resultobj = 0;
44424 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44425 wxBitmap *result = 0 ;
44426 void *argp1 = 0 ;
44427 int res1 = 0 ;
44428 PyObject *swig_obj[1] ;
44429
44430 if (!args) SWIG_fail;
44431 swig_obj[0] = args;
44432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44433 if (!SWIG_IsOK(res1)) {
44434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44435 }
44436 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44437 {
44438 PyThreadState* __tstate = wxPyBeginAllowThreads();
44439 {
44440 wxBitmap const &_result_ref = (arg1)->GetBitmap();
44441 result = (wxBitmap *) &_result_ref;
44442 }
44443 wxPyEndAllowThreads(__tstate);
44444 if (PyErr_Occurred()) SWIG_fail;
44445 }
44446 {
44447 wxBitmap* resultptr = new wxBitmap(*result);
44448 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44449 }
44450 return resultobj;
44451 fail:
44452 return NULL;
44453 }
44454
44455
44456 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44457 PyObject *resultobj = 0;
44458 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44459 wxFont *arg2 = 0 ;
44460 void *argp1 = 0 ;
44461 int res1 = 0 ;
44462 void *argp2 = 0 ;
44463 int res2 = 0 ;
44464 PyObject * obj0 = 0 ;
44465 PyObject * obj1 = 0 ;
44466 char * kwnames[] = {
44467 (char *) "self",(char *) "font", NULL
44468 };
44469
44470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44472 if (!SWIG_IsOK(res1)) {
44473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44474 }
44475 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44476 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44477 if (!SWIG_IsOK(res2)) {
44478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44479 }
44480 if (!argp2) {
44481 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44482 }
44483 arg2 = reinterpret_cast< wxFont * >(argp2);
44484 {
44485 PyThreadState* __tstate = wxPyBeginAllowThreads();
44486 (arg1)->SetFont((wxFont const &)*arg2);
44487 wxPyEndAllowThreads(__tstate);
44488 if (PyErr_Occurred()) SWIG_fail;
44489 }
44490 resultobj = SWIG_Py_Void();
44491 return resultobj;
44492 fail:
44493 return NULL;
44494 }
44495
44496
44497 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44498 PyObject *resultobj = 0;
44499 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44500 wxFont result;
44501 void *argp1 = 0 ;
44502 int res1 = 0 ;
44503 PyObject *swig_obj[1] ;
44504
44505 if (!args) SWIG_fail;
44506 swig_obj[0] = args;
44507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44508 if (!SWIG_IsOK(res1)) {
44509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44510 }
44511 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44512 {
44513 PyThreadState* __tstate = wxPyBeginAllowThreads();
44514 result = (arg1)->GetFont();
44515 wxPyEndAllowThreads(__tstate);
44516 if (PyErr_Occurred()) SWIG_fail;
44517 }
44518 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44519 return resultobj;
44520 fail:
44521 return NULL;
44522 }
44523
44524
44525 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44526 PyObject *resultobj = 0;
44527 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44528 wxColour *arg2 = 0 ;
44529 void *argp1 = 0 ;
44530 int res1 = 0 ;
44531 wxColour temp2 ;
44532 PyObject * obj0 = 0 ;
44533 PyObject * obj1 = 0 ;
44534 char * kwnames[] = {
44535 (char *) "self",(char *) "colText", NULL
44536 };
44537
44538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44540 if (!SWIG_IsOK(res1)) {
44541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44542 }
44543 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44544 {
44545 arg2 = &temp2;
44546 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44547 }
44548 {
44549 PyThreadState* __tstate = wxPyBeginAllowThreads();
44550 (arg1)->SetTextColour((wxColour const &)*arg2);
44551 wxPyEndAllowThreads(__tstate);
44552 if (PyErr_Occurred()) SWIG_fail;
44553 }
44554 resultobj = SWIG_Py_Void();
44555 return resultobj;
44556 fail:
44557 return NULL;
44558 }
44559
44560
44561 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44562 PyObject *resultobj = 0;
44563 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44564 wxColour result;
44565 void *argp1 = 0 ;
44566 int res1 = 0 ;
44567 PyObject *swig_obj[1] ;
44568
44569 if (!args) SWIG_fail;
44570 swig_obj[0] = args;
44571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44572 if (!SWIG_IsOK(res1)) {
44573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44574 }
44575 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44576 {
44577 PyThreadState* __tstate = wxPyBeginAllowThreads();
44578 result = (arg1)->GetTextColour();
44579 wxPyEndAllowThreads(__tstate);
44580 if (PyErr_Occurred()) SWIG_fail;
44581 }
44582 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44583 return resultobj;
44584 fail:
44585 return NULL;
44586 }
44587
44588
44589 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44590 PyObject *resultobj = 0;
44591 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44592 wxColour *arg2 = 0 ;
44593 void *argp1 = 0 ;
44594 int res1 = 0 ;
44595 wxColour temp2 ;
44596 PyObject * obj0 = 0 ;
44597 PyObject * obj1 = 0 ;
44598 char * kwnames[] = {
44599 (char *) "self",(char *) "colBack", NULL
44600 };
44601
44602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44604 if (!SWIG_IsOK(res1)) {
44605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44606 }
44607 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44608 {
44609 arg2 = &temp2;
44610 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44611 }
44612 {
44613 PyThreadState* __tstate = wxPyBeginAllowThreads();
44614 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
44615 wxPyEndAllowThreads(__tstate);
44616 if (PyErr_Occurred()) SWIG_fail;
44617 }
44618 resultobj = SWIG_Py_Void();
44619 return resultobj;
44620 fail:
44621 return NULL;
44622 }
44623
44624
44625 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44626 PyObject *resultobj = 0;
44627 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44628 wxColour result;
44629 void *argp1 = 0 ;
44630 int res1 = 0 ;
44631 PyObject *swig_obj[1] ;
44632
44633 if (!args) SWIG_fail;
44634 swig_obj[0] = args;
44635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44636 if (!SWIG_IsOK(res1)) {
44637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44638 }
44639 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44640 {
44641 PyThreadState* __tstate = wxPyBeginAllowThreads();
44642 result = (arg1)->GetBackgroundColour();
44643 wxPyEndAllowThreads(__tstate);
44644 if (PyErr_Occurred()) SWIG_fail;
44645 }
44646 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44647 return resultobj;
44648 fail:
44649 return NULL;
44650 }
44651
44652
44653 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44654 PyObject *resultobj = 0;
44655 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44656 wxBitmap *arg2 = 0 ;
44657 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44658 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44659 void *argp1 = 0 ;
44660 int res1 = 0 ;
44661 void *argp2 = 0 ;
44662 int res2 = 0 ;
44663 void *argp3 = 0 ;
44664 int res3 = 0 ;
44665 PyObject * obj0 = 0 ;
44666 PyObject * obj1 = 0 ;
44667 PyObject * obj2 = 0 ;
44668 char * kwnames[] = {
44669 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44670 };
44671
44672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44674 if (!SWIG_IsOK(res1)) {
44675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44676 }
44677 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44678 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44679 if (!SWIG_IsOK(res2)) {
44680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44681 }
44682 if (!argp2) {
44683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44684 }
44685 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44686 if (obj2) {
44687 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44688 if (!SWIG_IsOK(res3)) {
44689 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44690 }
44691 if (!argp3) {
44692 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44693 }
44694 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44695 }
44696 {
44697 PyThreadState* __tstate = wxPyBeginAllowThreads();
44698 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44699 wxPyEndAllowThreads(__tstate);
44700 if (PyErr_Occurred()) SWIG_fail;
44701 }
44702 resultobj = SWIG_Py_Void();
44703 return resultobj;
44704 fail:
44705 return NULL;
44706 }
44707
44708
44709 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44710 PyObject *resultobj = 0;
44711 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44712 wxBitmap *arg2 = 0 ;
44713 void *argp1 = 0 ;
44714 int res1 = 0 ;
44715 void *argp2 = 0 ;
44716 int res2 = 0 ;
44717 PyObject * obj0 = 0 ;
44718 PyObject * obj1 = 0 ;
44719 char * kwnames[] = {
44720 (char *) "self",(char *) "bmpDisabled", NULL
44721 };
44722
44723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44725 if (!SWIG_IsOK(res1)) {
44726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44727 }
44728 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44729 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44730 if (!SWIG_IsOK(res2)) {
44731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44732 }
44733 if (!argp2) {
44734 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44735 }
44736 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44737 {
44738 PyThreadState* __tstate = wxPyBeginAllowThreads();
44739 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
44740 wxPyEndAllowThreads(__tstate);
44741 if (PyErr_Occurred()) SWIG_fail;
44742 }
44743 resultobj = SWIG_Py_Void();
44744 return resultobj;
44745 fail:
44746 return NULL;
44747 }
44748
44749
44750 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44751 PyObject *resultobj = 0;
44752 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44753 wxBitmap *result = 0 ;
44754 void *argp1 = 0 ;
44755 int res1 = 0 ;
44756 PyObject *swig_obj[1] ;
44757
44758 if (!args) SWIG_fail;
44759 swig_obj[0] = args;
44760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44761 if (!SWIG_IsOK(res1)) {
44762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44763 }
44764 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44765 {
44766 PyThreadState* __tstate = wxPyBeginAllowThreads();
44767 {
44768 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
44769 result = (wxBitmap *) &_result_ref;
44770 }
44771 wxPyEndAllowThreads(__tstate);
44772 if (PyErr_Occurred()) SWIG_fail;
44773 }
44774 {
44775 wxBitmap* resultptr = new wxBitmap(*result);
44776 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44777 }
44778 return resultobj;
44779 fail:
44780 return NULL;
44781 }
44782
44783
44784 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44785 PyObject *resultobj = 0;
44786 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44787 int arg2 ;
44788 void *argp1 = 0 ;
44789 int res1 = 0 ;
44790 int val2 ;
44791 int ecode2 = 0 ;
44792 PyObject * obj0 = 0 ;
44793 PyObject * obj1 = 0 ;
44794 char * kwnames[] = {
44795 (char *) "self",(char *) "nWidth", NULL
44796 };
44797
44798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44800 if (!SWIG_IsOK(res1)) {
44801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44802 }
44803 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44804 ecode2 = SWIG_AsVal_int(obj1, &val2);
44805 if (!SWIG_IsOK(ecode2)) {
44806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44807 }
44808 arg2 = static_cast< int >(val2);
44809 {
44810 PyThreadState* __tstate = wxPyBeginAllowThreads();
44811 (arg1)->SetMarginWidth(arg2);
44812 wxPyEndAllowThreads(__tstate);
44813 if (PyErr_Occurred()) SWIG_fail;
44814 }
44815 resultobj = SWIG_Py_Void();
44816 return resultobj;
44817 fail:
44818 return NULL;
44819 }
44820
44821
44822 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44823 PyObject *resultobj = 0;
44824 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44825 int result;
44826 void *argp1 = 0 ;
44827 int res1 = 0 ;
44828 PyObject *swig_obj[1] ;
44829
44830 if (!args) SWIG_fail;
44831 swig_obj[0] = args;
44832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44833 if (!SWIG_IsOK(res1)) {
44834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44835 }
44836 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44837 {
44838 PyThreadState* __tstate = wxPyBeginAllowThreads();
44839 result = (int)(arg1)->GetMarginWidth();
44840 wxPyEndAllowThreads(__tstate);
44841 if (PyErr_Occurred()) SWIG_fail;
44842 }
44843 resultobj = SWIG_From_int(static_cast< int >(result));
44844 return resultobj;
44845 fail:
44846 return NULL;
44847 }
44848
44849
44850 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44851 PyObject *resultobj = 0;
44852 int result;
44853
44854 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44855 {
44856 PyThreadState* __tstate = wxPyBeginAllowThreads();
44857 result = (int)wxMenuItem::GetDefaultMarginWidth();
44858 wxPyEndAllowThreads(__tstate);
44859 if (PyErr_Occurred()) SWIG_fail;
44860 }
44861 resultobj = SWIG_From_int(static_cast< int >(result));
44862 return resultobj;
44863 fail:
44864 return NULL;
44865 }
44866
44867
44868 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44869 PyObject *resultobj = 0;
44870 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44871 bool result;
44872 void *argp1 = 0 ;
44873 int res1 = 0 ;
44874 PyObject *swig_obj[1] ;
44875
44876 if (!args) SWIG_fail;
44877 swig_obj[0] = args;
44878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44879 if (!SWIG_IsOK(res1)) {
44880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44881 }
44882 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44883 {
44884 PyThreadState* __tstate = wxPyBeginAllowThreads();
44885 result = (bool)(arg1)->IsOwnerDrawn();
44886 wxPyEndAllowThreads(__tstate);
44887 if (PyErr_Occurred()) SWIG_fail;
44888 }
44889 {
44890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44891 }
44892 return resultobj;
44893 fail:
44894 return NULL;
44895 }
44896
44897
44898 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44899 PyObject *resultobj = 0;
44900 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44901 bool arg2 = (bool) true ;
44902 void *argp1 = 0 ;
44903 int res1 = 0 ;
44904 bool val2 ;
44905 int ecode2 = 0 ;
44906 PyObject * obj0 = 0 ;
44907 PyObject * obj1 = 0 ;
44908 char * kwnames[] = {
44909 (char *) "self",(char *) "ownerDrawn", NULL
44910 };
44911
44912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44914 if (!SWIG_IsOK(res1)) {
44915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44916 }
44917 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44918 if (obj1) {
44919 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44920 if (!SWIG_IsOK(ecode2)) {
44921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44922 }
44923 arg2 = static_cast< bool >(val2);
44924 }
44925 {
44926 PyThreadState* __tstate = wxPyBeginAllowThreads();
44927 (arg1)->SetOwnerDrawn(arg2);
44928 wxPyEndAllowThreads(__tstate);
44929 if (PyErr_Occurred()) SWIG_fail;
44930 }
44931 resultobj = SWIG_Py_Void();
44932 return resultobj;
44933 fail:
44934 return NULL;
44935 }
44936
44937
44938 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44939 PyObject *resultobj = 0;
44940 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44941 void *argp1 = 0 ;
44942 int res1 = 0 ;
44943 PyObject *swig_obj[1] ;
44944
44945 if (!args) SWIG_fail;
44946 swig_obj[0] = args;
44947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44948 if (!SWIG_IsOK(res1)) {
44949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44950 }
44951 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44952 {
44953 PyThreadState* __tstate = wxPyBeginAllowThreads();
44954 (arg1)->ResetOwnerDrawn();
44955 wxPyEndAllowThreads(__tstate);
44956 if (PyErr_Occurred()) SWIG_fail;
44957 }
44958 resultobj = SWIG_Py_Void();
44959 return resultobj;
44960 fail:
44961 return NULL;
44962 }
44963
44964
44965 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44966 PyObject *obj;
44967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44968 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44969 return SWIG_Py_Void();
44970 }
44971
44972 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44973 return SWIG_Python_InitShadowInstance(args);
44974 }
44975
44976 SWIGINTERN int ControlNameStr_set(PyObject *) {
44977 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44978 return 1;
44979 }
44980
44981
44982 SWIGINTERN PyObject *ControlNameStr_get(void) {
44983 PyObject *pyobj = 0;
44984
44985 {
44986 #if wxUSE_UNICODE
44987 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44988 #else
44989 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44990 #endif
44991 }
44992 return pyobj;
44993 }
44994
44995
44996 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44997 PyObject *resultobj = 0;
44998 wxWindow *arg1 = (wxWindow *) 0 ;
44999 int arg2 = (int) -1 ;
45000 wxPoint const &arg3_defvalue = wxDefaultPosition ;
45001 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
45002 wxSize const &arg4_defvalue = wxDefaultSize ;
45003 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
45004 long arg5 = (long) 0 ;
45005 wxValidator const &arg6_defvalue = wxDefaultValidator ;
45006 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
45007 wxString const &arg7_defvalue = wxPyControlNameStr ;
45008 wxString *arg7 = (wxString *) &arg7_defvalue ;
45009 wxControl *result = 0 ;
45010 void *argp1 = 0 ;
45011 int res1 = 0 ;
45012 int val2 ;
45013 int ecode2 = 0 ;
45014 wxPoint temp3 ;
45015 wxSize temp4 ;
45016 long val5 ;
45017 int ecode5 = 0 ;
45018 void *argp6 = 0 ;
45019 int res6 = 0 ;
45020 bool temp7 = false ;
45021 PyObject * obj0 = 0 ;
45022 PyObject * obj1 = 0 ;
45023 PyObject * obj2 = 0 ;
45024 PyObject * obj3 = 0 ;
45025 PyObject * obj4 = 0 ;
45026 PyObject * obj5 = 0 ;
45027 PyObject * obj6 = 0 ;
45028 char * kwnames[] = {
45029 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45030 };
45031
45032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45034 if (!SWIG_IsOK(res1)) {
45035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
45036 }
45037 arg1 = reinterpret_cast< wxWindow * >(argp1);
45038 if (obj1) {
45039 ecode2 = SWIG_AsVal_int(obj1, &val2);
45040 if (!SWIG_IsOK(ecode2)) {
45041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
45042 }
45043 arg2 = static_cast< int >(val2);
45044 }
45045 if (obj2) {
45046 {
45047 arg3 = &temp3;
45048 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
45049 }
45050 }
45051 if (obj3) {
45052 {
45053 arg4 = &temp4;
45054 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
45055 }
45056 }
45057 if (obj4) {
45058 ecode5 = SWIG_AsVal_long(obj4, &val5);
45059 if (!SWIG_IsOK(ecode5)) {
45060 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
45061 }
45062 arg5 = static_cast< long >(val5);
45063 }
45064 if (obj5) {
45065 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
45066 if (!SWIG_IsOK(res6)) {
45067 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45068 }
45069 if (!argp6) {
45070 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45071 }
45072 arg6 = reinterpret_cast< wxValidator * >(argp6);
45073 }
45074 if (obj6) {
45075 {
45076 arg7 = wxString_in_helper(obj6);
45077 if (arg7 == NULL) SWIG_fail;
45078 temp7 = true;
45079 }
45080 }
45081 {
45082 if (!wxPyCheckForApp()) SWIG_fail;
45083 PyThreadState* __tstate = wxPyBeginAllowThreads();
45084 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
45085 wxPyEndAllowThreads(__tstate);
45086 if (PyErr_Occurred()) SWIG_fail;
45087 }
45088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
45089 {
45090 if (temp7)
45091 delete arg7;
45092 }
45093 return resultobj;
45094 fail:
45095 {
45096 if (temp7)
45097 delete arg7;
45098 }
45099 return NULL;
45100 }
45101
45102
45103 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45104 PyObject *resultobj = 0;
45105 wxControl *result = 0 ;
45106
45107 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
45108 {
45109 if (!wxPyCheckForApp()) SWIG_fail;
45110 PyThreadState* __tstate = wxPyBeginAllowThreads();
45111 result = (wxControl *)new wxControl();
45112 wxPyEndAllowThreads(__tstate);
45113 if (PyErr_Occurred()) SWIG_fail;
45114 }
45115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
45116 return resultobj;
45117 fail:
45118 return NULL;
45119 }
45120
45121
45122 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45123 PyObject *resultobj = 0;
45124 wxControl *arg1 = (wxControl *) 0 ;
45125 wxWindow *arg2 = (wxWindow *) 0 ;
45126 int arg3 = (int) -1 ;
45127 wxPoint const &arg4_defvalue = wxDefaultPosition ;
45128 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
45129 wxSize const &arg5_defvalue = wxDefaultSize ;
45130 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
45131 long arg6 = (long) 0 ;
45132 wxValidator const &arg7_defvalue = wxDefaultValidator ;
45133 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
45134 wxString const &arg8_defvalue = wxPyControlNameStr ;
45135 wxString *arg8 = (wxString *) &arg8_defvalue ;
45136 bool result;
45137 void *argp1 = 0 ;
45138 int res1 = 0 ;
45139 void *argp2 = 0 ;
45140 int res2 = 0 ;
45141 int val3 ;
45142 int ecode3 = 0 ;
45143 wxPoint temp4 ;
45144 wxSize temp5 ;
45145 long val6 ;
45146 int ecode6 = 0 ;
45147 void *argp7 = 0 ;
45148 int res7 = 0 ;
45149 bool temp8 = false ;
45150 PyObject * obj0 = 0 ;
45151 PyObject * obj1 = 0 ;
45152 PyObject * obj2 = 0 ;
45153 PyObject * obj3 = 0 ;
45154 PyObject * obj4 = 0 ;
45155 PyObject * obj5 = 0 ;
45156 PyObject * obj6 = 0 ;
45157 PyObject * obj7 = 0 ;
45158 char * kwnames[] = {
45159 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45160 };
45161
45162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
45163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45164 if (!SWIG_IsOK(res1)) {
45165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
45166 }
45167 arg1 = reinterpret_cast< wxControl * >(argp1);
45168 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45169 if (!SWIG_IsOK(res2)) {
45170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
45171 }
45172 arg2 = reinterpret_cast< wxWindow * >(argp2);
45173 if (obj2) {
45174 ecode3 = SWIG_AsVal_int(obj2, &val3);
45175 if (!SWIG_IsOK(ecode3)) {
45176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
45177 }
45178 arg3 = static_cast< int >(val3);
45179 }
45180 if (obj3) {
45181 {
45182 arg4 = &temp4;
45183 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
45184 }
45185 }
45186 if (obj4) {
45187 {
45188 arg5 = &temp5;
45189 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
45190 }
45191 }
45192 if (obj5) {
45193 ecode6 = SWIG_AsVal_long(obj5, &val6);
45194 if (!SWIG_IsOK(ecode6)) {
45195 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
45196 }
45197 arg6 = static_cast< long >(val6);
45198 }
45199 if (obj6) {
45200 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
45201 if (!SWIG_IsOK(res7)) {
45202 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45203 }
45204 if (!argp7) {
45205 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45206 }
45207 arg7 = reinterpret_cast< wxValidator * >(argp7);
45208 }
45209 if (obj7) {
45210 {
45211 arg8 = wxString_in_helper(obj7);
45212 if (arg8 == NULL) SWIG_fail;
45213 temp8 = true;
45214 }
45215 }
45216 {
45217 PyThreadState* __tstate = wxPyBeginAllowThreads();
45218 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
45219 wxPyEndAllowThreads(__tstate);
45220 if (PyErr_Occurred()) SWIG_fail;
45221 }
45222 {
45223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45224 }
45225 {
45226 if (temp8)
45227 delete arg8;
45228 }
45229 return resultobj;
45230 fail:
45231 {
45232 if (temp8)
45233 delete arg8;
45234 }
45235 return NULL;
45236 }
45237
45238
45239 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45240 PyObject *resultobj = 0;
45241 wxControl *arg1 = (wxControl *) 0 ;
45242 int result;
45243 void *argp1 = 0 ;
45244 int res1 = 0 ;
45245 PyObject *swig_obj[1] ;
45246
45247 if (!args) SWIG_fail;
45248 swig_obj[0] = args;
45249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45250 if (!SWIG_IsOK(res1)) {
45251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
45252 }
45253 arg1 = reinterpret_cast< wxControl * >(argp1);
45254 {
45255 PyThreadState* __tstate = wxPyBeginAllowThreads();
45256 result = (int)((wxControl const *)arg1)->GetAlignment();
45257 wxPyEndAllowThreads(__tstate);
45258 if (PyErr_Occurred()) SWIG_fail;
45259 }
45260 resultobj = SWIG_From_int(static_cast< int >(result));
45261 return resultobj;
45262 fail:
45263 return NULL;
45264 }
45265
45266
45267 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45268 PyObject *resultobj = 0;
45269 wxControl *arg1 = (wxControl *) 0 ;
45270 wxString result;
45271 void *argp1 = 0 ;
45272 int res1 = 0 ;
45273 PyObject *swig_obj[1] ;
45274
45275 if (!args) SWIG_fail;
45276 swig_obj[0] = args;
45277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45278 if (!SWIG_IsOK(res1)) {
45279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
45280 }
45281 arg1 = reinterpret_cast< wxControl * >(argp1);
45282 {
45283 PyThreadState* __tstate = wxPyBeginAllowThreads();
45284 result = ((wxControl const *)arg1)->GetLabelText();
45285 wxPyEndAllowThreads(__tstate);
45286 if (PyErr_Occurred()) SWIG_fail;
45287 }
45288 {
45289 #if wxUSE_UNICODE
45290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45291 #else
45292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45293 #endif
45294 }
45295 return resultobj;
45296 fail:
45297 return NULL;
45298 }
45299
45300
45301 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45302 PyObject *resultobj = 0;
45303 wxControl *arg1 = (wxControl *) 0 ;
45304 wxCommandEvent *arg2 = 0 ;
45305 void *argp1 = 0 ;
45306 int res1 = 0 ;
45307 void *argp2 = 0 ;
45308 int res2 = 0 ;
45309 PyObject * obj0 = 0 ;
45310 PyObject * obj1 = 0 ;
45311 char * kwnames[] = {
45312 (char *) "self",(char *) "event", NULL
45313 };
45314
45315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
45316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45317 if (!SWIG_IsOK(res1)) {
45318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
45319 }
45320 arg1 = reinterpret_cast< wxControl * >(argp1);
45321 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
45322 if (!SWIG_IsOK(res2)) {
45323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45324 }
45325 if (!argp2) {
45326 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45327 }
45328 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
45329 {
45330 PyThreadState* __tstate = wxPyBeginAllowThreads();
45331 (arg1)->Command(*arg2);
45332 wxPyEndAllowThreads(__tstate);
45333 if (PyErr_Occurred()) SWIG_fail;
45334 }
45335 resultobj = SWIG_Py_Void();
45336 return resultobj;
45337 fail:
45338 return NULL;
45339 }
45340
45341
45342 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45343 PyObject *resultobj = 0;
45344 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
45345 SwigValueWrapper<wxVisualAttributes > result;
45346 int val1 ;
45347 int ecode1 = 0 ;
45348 PyObject * obj0 = 0 ;
45349 char * kwnames[] = {
45350 (char *) "variant", NULL
45351 };
45352
45353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
45354 if (obj0) {
45355 ecode1 = SWIG_AsVal_int(obj0, &val1);
45356 if (!SWIG_IsOK(ecode1)) {
45357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
45358 }
45359 arg1 = static_cast< wxWindowVariant >(val1);
45360 }
45361 {
45362 if (!wxPyCheckForApp()) SWIG_fail;
45363 PyThreadState* __tstate = wxPyBeginAllowThreads();
45364 result = wxControl::GetClassDefaultAttributes(arg1);
45365 wxPyEndAllowThreads(__tstate);
45366 if (PyErr_Occurred()) SWIG_fail;
45367 }
45368 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
45369 return resultobj;
45370 fail:
45371 return NULL;
45372 }
45373
45374
45375 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45376 PyObject *obj;
45377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45378 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
45379 return SWIG_Py_Void();
45380 }
45381
45382 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45383 return SWIG_Python_InitShadowInstance(args);
45384 }
45385
45386 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45387 PyObject *resultobj = 0;
45388 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45389 wxString *arg2 = 0 ;
45390 PyObject *arg3 = (PyObject *) NULL ;
45391 int result;
45392 void *argp1 = 0 ;
45393 int res1 = 0 ;
45394 bool temp2 = false ;
45395 PyObject * obj0 = 0 ;
45396 PyObject * obj1 = 0 ;
45397 PyObject * obj2 = 0 ;
45398 char * kwnames[] = {
45399 (char *) "self",(char *) "item",(char *) "clientData", NULL
45400 };
45401
45402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45404 if (!SWIG_IsOK(res1)) {
45405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45406 }
45407 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45408 {
45409 arg2 = wxString_in_helper(obj1);
45410 if (arg2 == NULL) SWIG_fail;
45411 temp2 = true;
45412 }
45413 if (obj2) {
45414 arg3 = obj2;
45415 }
45416 {
45417 PyThreadState* __tstate = wxPyBeginAllowThreads();
45418 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
45419 wxPyEndAllowThreads(__tstate);
45420 if (PyErr_Occurred()) SWIG_fail;
45421 }
45422 resultobj = SWIG_From_int(static_cast< int >(result));
45423 {
45424 if (temp2)
45425 delete arg2;
45426 }
45427 return resultobj;
45428 fail:
45429 {
45430 if (temp2)
45431 delete arg2;
45432 }
45433 return NULL;
45434 }
45435
45436
45437 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45438 PyObject *resultobj = 0;
45439 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45440 wxArrayString *arg2 = 0 ;
45441 void *argp1 = 0 ;
45442 int res1 = 0 ;
45443 bool temp2 = false ;
45444 PyObject * obj0 = 0 ;
45445 PyObject * obj1 = 0 ;
45446 char * kwnames[] = {
45447 (char *) "self",(char *) "strings", NULL
45448 };
45449
45450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45452 if (!SWIG_IsOK(res1)) {
45453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45454 }
45455 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45456 {
45457 if (! PySequence_Check(obj1)) {
45458 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45459 SWIG_fail;
45460 }
45461 arg2 = new wxArrayString;
45462 temp2 = true;
45463 int i, len=PySequence_Length(obj1);
45464 for (i=0; i<len; i++) {
45465 PyObject* item = PySequence_GetItem(obj1, i);
45466 wxString* s = wxString_in_helper(item);
45467 if (PyErr_Occurred()) SWIG_fail;
45468 arg2->Add(*s);
45469 delete s;
45470 Py_DECREF(item);
45471 }
45472 }
45473 {
45474 PyThreadState* __tstate = wxPyBeginAllowThreads();
45475 (arg1)->Append((wxArrayString const &)*arg2);
45476 wxPyEndAllowThreads(__tstate);
45477 if (PyErr_Occurred()) SWIG_fail;
45478 }
45479 resultobj = SWIG_Py_Void();
45480 {
45481 if (temp2) delete arg2;
45482 }
45483 return resultobj;
45484 fail:
45485 {
45486 if (temp2) delete arg2;
45487 }
45488 return NULL;
45489 }
45490
45491
45492 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45493 PyObject *resultobj = 0;
45494 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45495 wxString *arg2 = 0 ;
45496 unsigned int arg3 ;
45497 PyObject *arg4 = (PyObject *) NULL ;
45498 int result;
45499 void *argp1 = 0 ;
45500 int res1 = 0 ;
45501 bool temp2 = false ;
45502 unsigned int val3 ;
45503 int ecode3 = 0 ;
45504 PyObject * obj0 = 0 ;
45505 PyObject * obj1 = 0 ;
45506 PyObject * obj2 = 0 ;
45507 PyObject * obj3 = 0 ;
45508 char * kwnames[] = {
45509 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45510 };
45511
45512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45514 if (!SWIG_IsOK(res1)) {
45515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45516 }
45517 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45518 {
45519 arg2 = wxString_in_helper(obj1);
45520 if (arg2 == NULL) SWIG_fail;
45521 temp2 = true;
45522 }
45523 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45524 if (!SWIG_IsOK(ecode3)) {
45525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45526 }
45527 arg3 = static_cast< unsigned int >(val3);
45528 if (obj3) {
45529 arg4 = obj3;
45530 }
45531 {
45532 PyThreadState* __tstate = wxPyBeginAllowThreads();
45533 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45534 wxPyEndAllowThreads(__tstate);
45535 if (PyErr_Occurred()) SWIG_fail;
45536 }
45537 resultobj = SWIG_From_int(static_cast< int >(result));
45538 {
45539 if (temp2)
45540 delete arg2;
45541 }
45542 return resultobj;
45543 fail:
45544 {
45545 if (temp2)
45546 delete arg2;
45547 }
45548 return NULL;
45549 }
45550
45551
45552 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45553 PyObject *resultobj = 0;
45554 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45555 void *argp1 = 0 ;
45556 int res1 = 0 ;
45557 PyObject *swig_obj[1] ;
45558
45559 if (!args) SWIG_fail;
45560 swig_obj[0] = args;
45561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45562 if (!SWIG_IsOK(res1)) {
45563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45564 }
45565 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45566 {
45567 PyThreadState* __tstate = wxPyBeginAllowThreads();
45568 (arg1)->Clear();
45569 wxPyEndAllowThreads(__tstate);
45570 if (PyErr_Occurred()) SWIG_fail;
45571 }
45572 resultobj = SWIG_Py_Void();
45573 return resultobj;
45574 fail:
45575 return NULL;
45576 }
45577
45578
45579 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45580 PyObject *resultobj = 0;
45581 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45582 unsigned int arg2 ;
45583 void *argp1 = 0 ;
45584 int res1 = 0 ;
45585 unsigned int val2 ;
45586 int ecode2 = 0 ;
45587 PyObject * obj0 = 0 ;
45588 PyObject * obj1 = 0 ;
45589 char * kwnames[] = {
45590 (char *) "self",(char *) "n", NULL
45591 };
45592
45593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45595 if (!SWIG_IsOK(res1)) {
45596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45597 }
45598 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45599 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45600 if (!SWIG_IsOK(ecode2)) {
45601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45602 }
45603 arg2 = static_cast< unsigned int >(val2);
45604 {
45605 PyThreadState* __tstate = wxPyBeginAllowThreads();
45606 (arg1)->Delete(arg2);
45607 wxPyEndAllowThreads(__tstate);
45608 if (PyErr_Occurred()) SWIG_fail;
45609 }
45610 resultobj = SWIG_Py_Void();
45611 return resultobj;
45612 fail:
45613 return NULL;
45614 }
45615
45616
45617 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45618 PyObject *resultobj = 0;
45619 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45620 unsigned int arg2 ;
45621 PyObject *result = 0 ;
45622 void *argp1 = 0 ;
45623 int res1 = 0 ;
45624 unsigned int val2 ;
45625 int ecode2 = 0 ;
45626 PyObject * obj0 = 0 ;
45627 PyObject * obj1 = 0 ;
45628 char * kwnames[] = {
45629 (char *) "self",(char *) "n", NULL
45630 };
45631
45632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45634 if (!SWIG_IsOK(res1)) {
45635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45636 }
45637 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45638 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45639 if (!SWIG_IsOK(ecode2)) {
45640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45641 }
45642 arg2 = static_cast< unsigned int >(val2);
45643 {
45644 PyThreadState* __tstate = wxPyBeginAllowThreads();
45645 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45646 wxPyEndAllowThreads(__tstate);
45647 if (PyErr_Occurred()) SWIG_fail;
45648 }
45649 resultobj = result;
45650 return resultobj;
45651 fail:
45652 return NULL;
45653 }
45654
45655
45656 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45657 PyObject *resultobj = 0;
45658 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45659 unsigned int arg2 ;
45660 PyObject *arg3 = (PyObject *) 0 ;
45661 void *argp1 = 0 ;
45662 int res1 = 0 ;
45663 unsigned int val2 ;
45664 int ecode2 = 0 ;
45665 PyObject * obj0 = 0 ;
45666 PyObject * obj1 = 0 ;
45667 PyObject * obj2 = 0 ;
45668 char * kwnames[] = {
45669 (char *) "self",(char *) "n",(char *) "clientData", NULL
45670 };
45671
45672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45674 if (!SWIG_IsOK(res1)) {
45675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45676 }
45677 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45678 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45679 if (!SWIG_IsOK(ecode2)) {
45680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45681 }
45682 arg2 = static_cast< unsigned int >(val2);
45683 arg3 = obj2;
45684 {
45685 PyThreadState* __tstate = wxPyBeginAllowThreads();
45686 wxItemContainer_SetClientData(arg1,arg2,arg3);
45687 wxPyEndAllowThreads(__tstate);
45688 if (PyErr_Occurred()) SWIG_fail;
45689 }
45690 resultobj = SWIG_Py_Void();
45691 return resultobj;
45692 fail:
45693 return NULL;
45694 }
45695
45696
45697 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45698 PyObject *resultobj = 0;
45699 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45700 unsigned int result;
45701 void *argp1 = 0 ;
45702 int res1 = 0 ;
45703 PyObject *swig_obj[1] ;
45704
45705 if (!args) SWIG_fail;
45706 swig_obj[0] = args;
45707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45708 if (!SWIG_IsOK(res1)) {
45709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45710 }
45711 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45712 {
45713 PyThreadState* __tstate = wxPyBeginAllowThreads();
45714 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45715 wxPyEndAllowThreads(__tstate);
45716 if (PyErr_Occurred()) SWIG_fail;
45717 }
45718 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45719 return resultobj;
45720 fail:
45721 return NULL;
45722 }
45723
45724
45725 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45726 PyObject *resultobj = 0;
45727 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45728 bool result;
45729 void *argp1 = 0 ;
45730 int res1 = 0 ;
45731 PyObject *swig_obj[1] ;
45732
45733 if (!args) SWIG_fail;
45734 swig_obj[0] = args;
45735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45736 if (!SWIG_IsOK(res1)) {
45737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45738 }
45739 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45740 {
45741 PyThreadState* __tstate = wxPyBeginAllowThreads();
45742 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45743 wxPyEndAllowThreads(__tstate);
45744 if (PyErr_Occurred()) SWIG_fail;
45745 }
45746 {
45747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45748 }
45749 return resultobj;
45750 fail:
45751 return NULL;
45752 }
45753
45754
45755 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45756 PyObject *resultobj = 0;
45757 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45758 unsigned int arg2 ;
45759 wxString result;
45760 void *argp1 = 0 ;
45761 int res1 = 0 ;
45762 unsigned int val2 ;
45763 int ecode2 = 0 ;
45764 PyObject * obj0 = 0 ;
45765 PyObject * obj1 = 0 ;
45766 char * kwnames[] = {
45767 (char *) "self",(char *) "n", NULL
45768 };
45769
45770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45772 if (!SWIG_IsOK(res1)) {
45773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45774 }
45775 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45776 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45777 if (!SWIG_IsOK(ecode2)) {
45778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45779 }
45780 arg2 = static_cast< unsigned int >(val2);
45781 {
45782 PyThreadState* __tstate = wxPyBeginAllowThreads();
45783 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45784 wxPyEndAllowThreads(__tstate);
45785 if (PyErr_Occurred()) SWIG_fail;
45786 }
45787 {
45788 #if wxUSE_UNICODE
45789 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45790 #else
45791 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45792 #endif
45793 }
45794 return resultobj;
45795 fail:
45796 return NULL;
45797 }
45798
45799
45800 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45801 PyObject *resultobj = 0;
45802 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45803 wxArrayString result;
45804 void *argp1 = 0 ;
45805 int res1 = 0 ;
45806 PyObject *swig_obj[1] ;
45807
45808 if (!args) SWIG_fail;
45809 swig_obj[0] = args;
45810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45811 if (!SWIG_IsOK(res1)) {
45812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45813 }
45814 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45815 {
45816 PyThreadState* __tstate = wxPyBeginAllowThreads();
45817 result = ((wxItemContainer const *)arg1)->GetStrings();
45818 wxPyEndAllowThreads(__tstate);
45819 if (PyErr_Occurred()) SWIG_fail;
45820 }
45821 {
45822 resultobj = wxArrayString2PyList_helper(result);
45823 }
45824 return resultobj;
45825 fail:
45826 return NULL;
45827 }
45828
45829
45830 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45831 PyObject *resultobj = 0;
45832 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45833 unsigned int arg2 ;
45834 wxString *arg3 = 0 ;
45835 void *argp1 = 0 ;
45836 int res1 = 0 ;
45837 unsigned int val2 ;
45838 int ecode2 = 0 ;
45839 bool temp3 = false ;
45840 PyObject * obj0 = 0 ;
45841 PyObject * obj1 = 0 ;
45842 PyObject * obj2 = 0 ;
45843 char * kwnames[] = {
45844 (char *) "self",(char *) "n",(char *) "s", NULL
45845 };
45846
45847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45849 if (!SWIG_IsOK(res1)) {
45850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45851 }
45852 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45853 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45854 if (!SWIG_IsOK(ecode2)) {
45855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45856 }
45857 arg2 = static_cast< unsigned int >(val2);
45858 {
45859 arg3 = wxString_in_helper(obj2);
45860 if (arg3 == NULL) SWIG_fail;
45861 temp3 = true;
45862 }
45863 {
45864 PyThreadState* __tstate = wxPyBeginAllowThreads();
45865 (arg1)->SetString(arg2,(wxString const &)*arg3);
45866 wxPyEndAllowThreads(__tstate);
45867 if (PyErr_Occurred()) SWIG_fail;
45868 }
45869 resultobj = SWIG_Py_Void();
45870 {
45871 if (temp3)
45872 delete arg3;
45873 }
45874 return resultobj;
45875 fail:
45876 {
45877 if (temp3)
45878 delete arg3;
45879 }
45880 return NULL;
45881 }
45882
45883
45884 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45885 PyObject *resultobj = 0;
45886 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45887 wxString *arg2 = 0 ;
45888 int result;
45889 void *argp1 = 0 ;
45890 int res1 = 0 ;
45891 bool temp2 = false ;
45892 PyObject * obj0 = 0 ;
45893 PyObject * obj1 = 0 ;
45894 char * kwnames[] = {
45895 (char *) "self",(char *) "s", NULL
45896 };
45897
45898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45900 if (!SWIG_IsOK(res1)) {
45901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45902 }
45903 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45904 {
45905 arg2 = wxString_in_helper(obj1);
45906 if (arg2 == NULL) SWIG_fail;
45907 temp2 = true;
45908 }
45909 {
45910 PyThreadState* __tstate = wxPyBeginAllowThreads();
45911 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45912 wxPyEndAllowThreads(__tstate);
45913 if (PyErr_Occurred()) SWIG_fail;
45914 }
45915 resultobj = SWIG_From_int(static_cast< int >(result));
45916 {
45917 if (temp2)
45918 delete arg2;
45919 }
45920 return resultobj;
45921 fail:
45922 {
45923 if (temp2)
45924 delete arg2;
45925 }
45926 return NULL;
45927 }
45928
45929
45930 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45931 PyObject *resultobj = 0;
45932 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45933 int arg2 ;
45934 void *argp1 = 0 ;
45935 int res1 = 0 ;
45936 int val2 ;
45937 int ecode2 = 0 ;
45938 PyObject * obj0 = 0 ;
45939 PyObject * obj1 = 0 ;
45940 char * kwnames[] = {
45941 (char *) "self",(char *) "n", NULL
45942 };
45943
45944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45946 if (!SWIG_IsOK(res1)) {
45947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45948 }
45949 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45950 ecode2 = SWIG_AsVal_int(obj1, &val2);
45951 if (!SWIG_IsOK(ecode2)) {
45952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45953 }
45954 arg2 = static_cast< int >(val2);
45955 {
45956 PyThreadState* __tstate = wxPyBeginAllowThreads();
45957 (arg1)->SetSelection(arg2);
45958 wxPyEndAllowThreads(__tstate);
45959 if (PyErr_Occurred()) SWIG_fail;
45960 }
45961 resultobj = SWIG_Py_Void();
45962 return resultobj;
45963 fail:
45964 return NULL;
45965 }
45966
45967
45968 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45969 PyObject *resultobj = 0;
45970 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45971 int result;
45972 void *argp1 = 0 ;
45973 int res1 = 0 ;
45974 PyObject *swig_obj[1] ;
45975
45976 if (!args) SWIG_fail;
45977 swig_obj[0] = args;
45978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45979 if (!SWIG_IsOK(res1)) {
45980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45981 }
45982 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45983 {
45984 PyThreadState* __tstate = wxPyBeginAllowThreads();
45985 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45986 wxPyEndAllowThreads(__tstate);
45987 if (PyErr_Occurred()) SWIG_fail;
45988 }
45989 resultobj = SWIG_From_int(static_cast< int >(result));
45990 return resultobj;
45991 fail:
45992 return NULL;
45993 }
45994
45995
45996 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45997 PyObject *resultobj = 0;
45998 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45999 wxString *arg2 = 0 ;
46000 bool result;
46001 void *argp1 = 0 ;
46002 int res1 = 0 ;
46003 bool temp2 = false ;
46004 PyObject * obj0 = 0 ;
46005 PyObject * obj1 = 0 ;
46006 char * kwnames[] = {
46007 (char *) "self",(char *) "s", NULL
46008 };
46009
46010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46012 if (!SWIG_IsOK(res1)) {
46013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46014 }
46015 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46016 {
46017 arg2 = wxString_in_helper(obj1);
46018 if (arg2 == NULL) SWIG_fail;
46019 temp2 = true;
46020 }
46021 {
46022 PyThreadState* __tstate = wxPyBeginAllowThreads();
46023 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
46024 wxPyEndAllowThreads(__tstate);
46025 if (PyErr_Occurred()) SWIG_fail;
46026 }
46027 {
46028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46029 }
46030 {
46031 if (temp2)
46032 delete arg2;
46033 }
46034 return resultobj;
46035 fail:
46036 {
46037 if (temp2)
46038 delete arg2;
46039 }
46040 return NULL;
46041 }
46042
46043
46044 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46045 PyObject *resultobj = 0;
46046 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46047 wxString result;
46048 void *argp1 = 0 ;
46049 int res1 = 0 ;
46050 PyObject *swig_obj[1] ;
46051
46052 if (!args) SWIG_fail;
46053 swig_obj[0] = args;
46054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46055 if (!SWIG_IsOK(res1)) {
46056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46057 }
46058 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46059 {
46060 PyThreadState* __tstate = wxPyBeginAllowThreads();
46061 result = ((wxItemContainer const *)arg1)->GetStringSelection();
46062 wxPyEndAllowThreads(__tstate);
46063 if (PyErr_Occurred()) SWIG_fail;
46064 }
46065 {
46066 #if wxUSE_UNICODE
46067 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46068 #else
46069 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46070 #endif
46071 }
46072 return resultobj;
46073 fail:
46074 return NULL;
46075 }
46076
46077
46078 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46079 PyObject *resultobj = 0;
46080 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46081 int arg2 ;
46082 void *argp1 = 0 ;
46083 int res1 = 0 ;
46084 int val2 ;
46085 int ecode2 = 0 ;
46086 PyObject * obj0 = 0 ;
46087 PyObject * obj1 = 0 ;
46088 char * kwnames[] = {
46089 (char *) "self",(char *) "n", NULL
46090 };
46091
46092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
46093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46094 if (!SWIG_IsOK(res1)) {
46095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46096 }
46097 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46098 ecode2 = SWIG_AsVal_int(obj1, &val2);
46099 if (!SWIG_IsOK(ecode2)) {
46100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
46101 }
46102 arg2 = static_cast< int >(val2);
46103 {
46104 PyThreadState* __tstate = wxPyBeginAllowThreads();
46105 (arg1)->Select(arg2);
46106 wxPyEndAllowThreads(__tstate);
46107 if (PyErr_Occurred()) SWIG_fail;
46108 }
46109 resultobj = SWIG_Py_Void();
46110 return resultobj;
46111 fail:
46112 return NULL;
46113 }
46114
46115
46116 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46117 PyObject *obj;
46118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46119 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
46120 return SWIG_Py_Void();
46121 }
46122
46123 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46124 PyObject *obj;
46125 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46126 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
46127 return SWIG_Py_Void();
46128 }
46129
46130 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46131 PyObject *resultobj = 0;
46132 wxSizerItem *result = 0 ;
46133
46134 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
46135 {
46136 PyThreadState* __tstate = wxPyBeginAllowThreads();
46137 result = (wxSizerItem *)new wxSizerItem();
46138 wxPyEndAllowThreads(__tstate);
46139 if (PyErr_Occurred()) SWIG_fail;
46140 }
46141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
46142 return resultobj;
46143 fail:
46144 return NULL;
46145 }
46146
46147
46148 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46149 PyObject *resultobj = 0;
46150 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46151 void *argp1 = 0 ;
46152 int res1 = 0 ;
46153 PyObject *swig_obj[1] ;
46154
46155 if (!args) SWIG_fail;
46156 swig_obj[0] = args;
46157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46158 if (!SWIG_IsOK(res1)) {
46159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46160 }
46161 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46162 {
46163 PyThreadState* __tstate = wxPyBeginAllowThreads();
46164 delete arg1;
46165
46166 wxPyEndAllowThreads(__tstate);
46167 if (PyErr_Occurred()) SWIG_fail;
46168 }
46169 resultobj = SWIG_Py_Void();
46170 return resultobj;
46171 fail:
46172 return NULL;
46173 }
46174
46175
46176 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46177 PyObject *resultobj = 0;
46178 wxWindow *arg1 = (wxWindow *) 0 ;
46179 int arg2 ;
46180 int arg3 ;
46181 int arg4 ;
46182 PyObject *arg5 = (PyObject *) NULL ;
46183 wxSizerItem *result = 0 ;
46184 void *argp1 = 0 ;
46185 int res1 = 0 ;
46186 int val2 ;
46187 int ecode2 = 0 ;
46188 int val3 ;
46189 int ecode3 = 0 ;
46190 int val4 ;
46191 int ecode4 = 0 ;
46192 PyObject * obj0 = 0 ;
46193 PyObject * obj1 = 0 ;
46194 PyObject * obj2 = 0 ;
46195 PyObject * obj3 = 0 ;
46196 PyObject * obj4 = 0 ;
46197 char * kwnames[] = {
46198 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46199 };
46200
46201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
46203 if (!SWIG_IsOK(res1)) {
46204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
46205 }
46206 arg1 = reinterpret_cast< wxWindow * >(argp1);
46207 ecode2 = SWIG_AsVal_int(obj1, &val2);
46208 if (!SWIG_IsOK(ecode2)) {
46209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
46210 }
46211 arg2 = static_cast< int >(val2);
46212 ecode3 = SWIG_AsVal_int(obj2, &val3);
46213 if (!SWIG_IsOK(ecode3)) {
46214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
46215 }
46216 arg3 = static_cast< int >(val3);
46217 ecode4 = SWIG_AsVal_int(obj3, &val4);
46218 if (!SWIG_IsOK(ecode4)) {
46219 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
46220 }
46221 arg4 = static_cast< int >(val4);
46222 if (obj4) {
46223 arg5 = obj4;
46224 }
46225 {
46226 PyThreadState* __tstate = wxPyBeginAllowThreads();
46227 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46228 wxPyEndAllowThreads(__tstate);
46229 if (PyErr_Occurred()) SWIG_fail;
46230 }
46231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46232 return resultobj;
46233 fail:
46234 return NULL;
46235 }
46236
46237
46238 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46239 PyObject *resultobj = 0;
46240 int arg1 ;
46241 int arg2 ;
46242 int arg3 ;
46243 int arg4 ;
46244 int arg5 ;
46245 PyObject *arg6 = (PyObject *) NULL ;
46246 wxSizerItem *result = 0 ;
46247 int val1 ;
46248 int ecode1 = 0 ;
46249 int val2 ;
46250 int ecode2 = 0 ;
46251 int val3 ;
46252 int ecode3 = 0 ;
46253 int val4 ;
46254 int ecode4 = 0 ;
46255 int val5 ;
46256 int ecode5 = 0 ;
46257 PyObject * obj0 = 0 ;
46258 PyObject * obj1 = 0 ;
46259 PyObject * obj2 = 0 ;
46260 PyObject * obj3 = 0 ;
46261 PyObject * obj4 = 0 ;
46262 PyObject * obj5 = 0 ;
46263 char * kwnames[] = {
46264 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46265 };
46266
46267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46268 ecode1 = SWIG_AsVal_int(obj0, &val1);
46269 if (!SWIG_IsOK(ecode1)) {
46270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
46271 }
46272 arg1 = static_cast< int >(val1);
46273 ecode2 = SWIG_AsVal_int(obj1, &val2);
46274 if (!SWIG_IsOK(ecode2)) {
46275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
46276 }
46277 arg2 = static_cast< int >(val2);
46278 ecode3 = SWIG_AsVal_int(obj2, &val3);
46279 if (!SWIG_IsOK(ecode3)) {
46280 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
46281 }
46282 arg3 = static_cast< int >(val3);
46283 ecode4 = SWIG_AsVal_int(obj3, &val4);
46284 if (!SWIG_IsOK(ecode4)) {
46285 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
46286 }
46287 arg4 = static_cast< int >(val4);
46288 ecode5 = SWIG_AsVal_int(obj4, &val5);
46289 if (!SWIG_IsOK(ecode5)) {
46290 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
46291 }
46292 arg5 = static_cast< int >(val5);
46293 if (obj5) {
46294 arg6 = obj5;
46295 }
46296 {
46297 PyThreadState* __tstate = wxPyBeginAllowThreads();
46298 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
46299 wxPyEndAllowThreads(__tstate);
46300 if (PyErr_Occurred()) SWIG_fail;
46301 }
46302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46303 return resultobj;
46304 fail:
46305 return NULL;
46306 }
46307
46308
46309 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46310 PyObject *resultobj = 0;
46311 wxSizer *arg1 = (wxSizer *) 0 ;
46312 int arg2 ;
46313 int arg3 ;
46314 int arg4 ;
46315 PyObject *arg5 = (PyObject *) NULL ;
46316 wxSizerItem *result = 0 ;
46317 int res1 = 0 ;
46318 int val2 ;
46319 int ecode2 = 0 ;
46320 int val3 ;
46321 int ecode3 = 0 ;
46322 int val4 ;
46323 int ecode4 = 0 ;
46324 PyObject * obj0 = 0 ;
46325 PyObject * obj1 = 0 ;
46326 PyObject * obj2 = 0 ;
46327 PyObject * obj3 = 0 ;
46328 PyObject * obj4 = 0 ;
46329 char * kwnames[] = {
46330 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46331 };
46332
46333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46334 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46335 if (!SWIG_IsOK(res1)) {
46336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46337 }
46338 ecode2 = SWIG_AsVal_int(obj1, &val2);
46339 if (!SWIG_IsOK(ecode2)) {
46340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
46341 }
46342 arg2 = static_cast< int >(val2);
46343 ecode3 = SWIG_AsVal_int(obj2, &val3);
46344 if (!SWIG_IsOK(ecode3)) {
46345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
46346 }
46347 arg3 = static_cast< int >(val3);
46348 ecode4 = SWIG_AsVal_int(obj3, &val4);
46349 if (!SWIG_IsOK(ecode4)) {
46350 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
46351 }
46352 arg4 = static_cast< int >(val4);
46353 if (obj4) {
46354 arg5 = obj4;
46355 }
46356 {
46357 PyThreadState* __tstate = wxPyBeginAllowThreads();
46358 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46359 wxPyEndAllowThreads(__tstate);
46360 if (PyErr_Occurred()) SWIG_fail;
46361 }
46362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46363 return resultobj;
46364 fail:
46365 return NULL;
46366 }
46367
46368
46369 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46370 PyObject *resultobj = 0;
46371 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46372 void *argp1 = 0 ;
46373 int res1 = 0 ;
46374 PyObject *swig_obj[1] ;
46375
46376 if (!args) SWIG_fail;
46377 swig_obj[0] = args;
46378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46379 if (!SWIG_IsOK(res1)) {
46380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46381 }
46382 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46383 {
46384 PyThreadState* __tstate = wxPyBeginAllowThreads();
46385 (arg1)->DeleteWindows();
46386 wxPyEndAllowThreads(__tstate);
46387 if (PyErr_Occurred()) SWIG_fail;
46388 }
46389 resultobj = SWIG_Py_Void();
46390 return resultobj;
46391 fail:
46392 return NULL;
46393 }
46394
46395
46396 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46397 PyObject *resultobj = 0;
46398 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46399 void *argp1 = 0 ;
46400 int res1 = 0 ;
46401 PyObject *swig_obj[1] ;
46402
46403 if (!args) SWIG_fail;
46404 swig_obj[0] = args;
46405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46406 if (!SWIG_IsOK(res1)) {
46407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46408 }
46409 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46410 {
46411 PyThreadState* __tstate = wxPyBeginAllowThreads();
46412 (arg1)->DetachSizer();
46413 wxPyEndAllowThreads(__tstate);
46414 if (PyErr_Occurred()) SWIG_fail;
46415 }
46416 resultobj = SWIG_Py_Void();
46417 return resultobj;
46418 fail:
46419 return NULL;
46420 }
46421
46422
46423 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46424 PyObject *resultobj = 0;
46425 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46426 wxSize result;
46427 void *argp1 = 0 ;
46428 int res1 = 0 ;
46429 PyObject *swig_obj[1] ;
46430
46431 if (!args) SWIG_fail;
46432 swig_obj[0] = args;
46433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46434 if (!SWIG_IsOK(res1)) {
46435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46436 }
46437 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46438 {
46439 PyThreadState* __tstate = wxPyBeginAllowThreads();
46440 result = (arg1)->GetSize();
46441 wxPyEndAllowThreads(__tstate);
46442 if (PyErr_Occurred()) SWIG_fail;
46443 }
46444 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46445 return resultobj;
46446 fail:
46447 return NULL;
46448 }
46449
46450
46451 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46452 PyObject *resultobj = 0;
46453 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46454 wxSize result;
46455 void *argp1 = 0 ;
46456 int res1 = 0 ;
46457 PyObject *swig_obj[1] ;
46458
46459 if (!args) SWIG_fail;
46460 swig_obj[0] = args;
46461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46462 if (!SWIG_IsOK(res1)) {
46463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46464 }
46465 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46466 {
46467 PyThreadState* __tstate = wxPyBeginAllowThreads();
46468 result = (arg1)->CalcMin();
46469 wxPyEndAllowThreads(__tstate);
46470 if (PyErr_Occurred()) SWIG_fail;
46471 }
46472 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46473 return resultobj;
46474 fail:
46475 return NULL;
46476 }
46477
46478
46479 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46480 PyObject *resultobj = 0;
46481 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46482 wxPoint *arg2 = 0 ;
46483 wxSize *arg3 = 0 ;
46484 void *argp1 = 0 ;
46485 int res1 = 0 ;
46486 wxPoint temp2 ;
46487 wxSize temp3 ;
46488 PyObject * obj0 = 0 ;
46489 PyObject * obj1 = 0 ;
46490 PyObject * obj2 = 0 ;
46491 char * kwnames[] = {
46492 (char *) "self",(char *) "pos",(char *) "size", NULL
46493 };
46494
46495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46497 if (!SWIG_IsOK(res1)) {
46498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46499 }
46500 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46501 {
46502 arg2 = &temp2;
46503 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46504 }
46505 {
46506 arg3 = &temp3;
46507 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46508 }
46509 {
46510 PyThreadState* __tstate = wxPyBeginAllowThreads();
46511 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46512 wxPyEndAllowThreads(__tstate);
46513 if (PyErr_Occurred()) SWIG_fail;
46514 }
46515 resultobj = SWIG_Py_Void();
46516 return resultobj;
46517 fail:
46518 return NULL;
46519 }
46520
46521
46522 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46523 PyObject *resultobj = 0;
46524 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46525 wxSize result;
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_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46535 }
46536 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46537 {
46538 PyThreadState* __tstate = wxPyBeginAllowThreads();
46539 result = (arg1)->GetMinSize();
46540 wxPyEndAllowThreads(__tstate);
46541 if (PyErr_Occurred()) SWIG_fail;
46542 }
46543 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46544 return resultobj;
46545 fail:
46546 return NULL;
46547 }
46548
46549
46550 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46551 PyObject *resultobj = 0;
46552 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46553 wxSize result;
46554 void *argp1 = 0 ;
46555 int res1 = 0 ;
46556 PyObject *swig_obj[1] ;
46557
46558 if (!args) SWIG_fail;
46559 swig_obj[0] = args;
46560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46561 if (!SWIG_IsOK(res1)) {
46562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46563 }
46564 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46565 {
46566 PyThreadState* __tstate = wxPyBeginAllowThreads();
46567 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46568 wxPyEndAllowThreads(__tstate);
46569 if (PyErr_Occurred()) SWIG_fail;
46570 }
46571 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46572 return resultobj;
46573 fail:
46574 return NULL;
46575 }
46576
46577
46578 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46579 PyObject *resultobj = 0;
46580 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46581 int arg2 ;
46582 int arg3 ;
46583 void *argp1 = 0 ;
46584 int res1 = 0 ;
46585 int val2 ;
46586 int ecode2 = 0 ;
46587 int val3 ;
46588 int ecode3 = 0 ;
46589 PyObject * obj0 = 0 ;
46590 PyObject * obj1 = 0 ;
46591 PyObject * obj2 = 0 ;
46592 char * kwnames[] = {
46593 (char *) "self",(char *) "x",(char *) "y", NULL
46594 };
46595
46596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46598 if (!SWIG_IsOK(res1)) {
46599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46600 }
46601 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46602 ecode2 = SWIG_AsVal_int(obj1, &val2);
46603 if (!SWIG_IsOK(ecode2)) {
46604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46605 }
46606 arg2 = static_cast< int >(val2);
46607 ecode3 = SWIG_AsVal_int(obj2, &val3);
46608 if (!SWIG_IsOK(ecode3)) {
46609 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46610 }
46611 arg3 = static_cast< int >(val3);
46612 {
46613 PyThreadState* __tstate = wxPyBeginAllowThreads();
46614 (arg1)->SetInitSize(arg2,arg3);
46615 wxPyEndAllowThreads(__tstate);
46616 if (PyErr_Occurred()) SWIG_fail;
46617 }
46618 resultobj = SWIG_Py_Void();
46619 return resultobj;
46620 fail:
46621 return NULL;
46622 }
46623
46624
46625 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46626 PyObject *resultobj = 0;
46627 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46628 int arg2 ;
46629 int arg3 ;
46630 void *argp1 = 0 ;
46631 int res1 = 0 ;
46632 int val2 ;
46633 int ecode2 = 0 ;
46634 int val3 ;
46635 int ecode3 = 0 ;
46636 PyObject * obj0 = 0 ;
46637 PyObject * obj1 = 0 ;
46638 PyObject * obj2 = 0 ;
46639 char * kwnames[] = {
46640 (char *) "self",(char *) "width",(char *) "height", NULL
46641 };
46642
46643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46645 if (!SWIG_IsOK(res1)) {
46646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46647 }
46648 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46649 ecode2 = SWIG_AsVal_int(obj1, &val2);
46650 if (!SWIG_IsOK(ecode2)) {
46651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46652 }
46653 arg2 = static_cast< int >(val2);
46654 ecode3 = SWIG_AsVal_int(obj2, &val3);
46655 if (!SWIG_IsOK(ecode3)) {
46656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46657 }
46658 arg3 = static_cast< int >(val3);
46659 {
46660 PyThreadState* __tstate = wxPyBeginAllowThreads();
46661 (arg1)->SetRatio(arg2,arg3);
46662 wxPyEndAllowThreads(__tstate);
46663 if (PyErr_Occurred()) SWIG_fail;
46664 }
46665 resultobj = SWIG_Py_Void();
46666 return resultobj;
46667 fail:
46668 return NULL;
46669 }
46670
46671
46672 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46673 PyObject *resultobj = 0;
46674 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46675 wxSize *arg2 = 0 ;
46676 void *argp1 = 0 ;
46677 int res1 = 0 ;
46678 wxSize temp2 ;
46679 PyObject * obj0 = 0 ;
46680 PyObject * obj1 = 0 ;
46681 char * kwnames[] = {
46682 (char *) "self",(char *) "size", NULL
46683 };
46684
46685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46687 if (!SWIG_IsOK(res1)) {
46688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46689 }
46690 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46691 {
46692 arg2 = &temp2;
46693 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46694 }
46695 {
46696 PyThreadState* __tstate = wxPyBeginAllowThreads();
46697 (arg1)->SetRatio((wxSize const &)*arg2);
46698 wxPyEndAllowThreads(__tstate);
46699 if (PyErr_Occurred()) SWIG_fail;
46700 }
46701 resultobj = SWIG_Py_Void();
46702 return resultobj;
46703 fail:
46704 return NULL;
46705 }
46706
46707
46708 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46709 PyObject *resultobj = 0;
46710 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46711 float arg2 ;
46712 void *argp1 = 0 ;
46713 int res1 = 0 ;
46714 float val2 ;
46715 int ecode2 = 0 ;
46716 PyObject * obj0 = 0 ;
46717 PyObject * obj1 = 0 ;
46718 char * kwnames[] = {
46719 (char *) "self",(char *) "ratio", NULL
46720 };
46721
46722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46724 if (!SWIG_IsOK(res1)) {
46725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46726 }
46727 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46728 ecode2 = SWIG_AsVal_float(obj1, &val2);
46729 if (!SWIG_IsOK(ecode2)) {
46730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46731 }
46732 arg2 = static_cast< float >(val2);
46733 {
46734 PyThreadState* __tstate = wxPyBeginAllowThreads();
46735 (arg1)->SetRatio(arg2);
46736 wxPyEndAllowThreads(__tstate);
46737 if (PyErr_Occurred()) SWIG_fail;
46738 }
46739 resultobj = SWIG_Py_Void();
46740 return resultobj;
46741 fail:
46742 return NULL;
46743 }
46744
46745
46746 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46747 PyObject *resultobj = 0;
46748 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46749 float result;
46750 void *argp1 = 0 ;
46751 int res1 = 0 ;
46752 PyObject *swig_obj[1] ;
46753
46754 if (!args) SWIG_fail;
46755 swig_obj[0] = args;
46756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46757 if (!SWIG_IsOK(res1)) {
46758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46759 }
46760 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46761 {
46762 PyThreadState* __tstate = wxPyBeginAllowThreads();
46763 result = (float)(arg1)->GetRatio();
46764 wxPyEndAllowThreads(__tstate);
46765 if (PyErr_Occurred()) SWIG_fail;
46766 }
46767 resultobj = SWIG_From_float(static_cast< float >(result));
46768 return resultobj;
46769 fail:
46770 return NULL;
46771 }
46772
46773
46774 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46775 PyObject *resultobj = 0;
46776 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46777 wxRect result;
46778 void *argp1 = 0 ;
46779 int res1 = 0 ;
46780 PyObject *swig_obj[1] ;
46781
46782 if (!args) SWIG_fail;
46783 swig_obj[0] = args;
46784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46785 if (!SWIG_IsOK(res1)) {
46786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46787 }
46788 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46789 {
46790 PyThreadState* __tstate = wxPyBeginAllowThreads();
46791 result = (arg1)->GetRect();
46792 wxPyEndAllowThreads(__tstate);
46793 if (PyErr_Occurred()) SWIG_fail;
46794 }
46795 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46796 return resultobj;
46797 fail:
46798 return NULL;
46799 }
46800
46801
46802 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46803 PyObject *resultobj = 0;
46804 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46805 bool result;
46806 void *argp1 = 0 ;
46807 int res1 = 0 ;
46808 PyObject *swig_obj[1] ;
46809
46810 if (!args) SWIG_fail;
46811 swig_obj[0] = args;
46812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46813 if (!SWIG_IsOK(res1)) {
46814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46815 }
46816 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46817 {
46818 PyThreadState* __tstate = wxPyBeginAllowThreads();
46819 result = (bool)(arg1)->IsWindow();
46820 wxPyEndAllowThreads(__tstate);
46821 if (PyErr_Occurred()) SWIG_fail;
46822 }
46823 {
46824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46825 }
46826 return resultobj;
46827 fail:
46828 return NULL;
46829 }
46830
46831
46832 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46833 PyObject *resultobj = 0;
46834 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46835 bool result;
46836 void *argp1 = 0 ;
46837 int res1 = 0 ;
46838 PyObject *swig_obj[1] ;
46839
46840 if (!args) SWIG_fail;
46841 swig_obj[0] = args;
46842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46843 if (!SWIG_IsOK(res1)) {
46844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46845 }
46846 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46847 {
46848 PyThreadState* __tstate = wxPyBeginAllowThreads();
46849 result = (bool)(arg1)->IsSizer();
46850 wxPyEndAllowThreads(__tstate);
46851 if (PyErr_Occurred()) SWIG_fail;
46852 }
46853 {
46854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46855 }
46856 return resultobj;
46857 fail:
46858 return NULL;
46859 }
46860
46861
46862 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46863 PyObject *resultobj = 0;
46864 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46865 bool result;
46866 void *argp1 = 0 ;
46867 int res1 = 0 ;
46868 PyObject *swig_obj[1] ;
46869
46870 if (!args) SWIG_fail;
46871 swig_obj[0] = args;
46872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46873 if (!SWIG_IsOK(res1)) {
46874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46875 }
46876 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46877 {
46878 PyThreadState* __tstate = wxPyBeginAllowThreads();
46879 result = (bool)(arg1)->IsSpacer();
46880 wxPyEndAllowThreads(__tstate);
46881 if (PyErr_Occurred()) SWIG_fail;
46882 }
46883 {
46884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46885 }
46886 return resultobj;
46887 fail:
46888 return NULL;
46889 }
46890
46891
46892 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46893 PyObject *resultobj = 0;
46894 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46895 int arg2 ;
46896 void *argp1 = 0 ;
46897 int res1 = 0 ;
46898 int val2 ;
46899 int ecode2 = 0 ;
46900 PyObject * obj0 = 0 ;
46901 PyObject * obj1 = 0 ;
46902 char * kwnames[] = {
46903 (char *) "self",(char *) "proportion", NULL
46904 };
46905
46906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46908 if (!SWIG_IsOK(res1)) {
46909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46910 }
46911 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46912 ecode2 = SWIG_AsVal_int(obj1, &val2);
46913 if (!SWIG_IsOK(ecode2)) {
46914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46915 }
46916 arg2 = static_cast< int >(val2);
46917 {
46918 PyThreadState* __tstate = wxPyBeginAllowThreads();
46919 (arg1)->SetProportion(arg2);
46920 wxPyEndAllowThreads(__tstate);
46921 if (PyErr_Occurred()) SWIG_fail;
46922 }
46923 resultobj = SWIG_Py_Void();
46924 return resultobj;
46925 fail:
46926 return NULL;
46927 }
46928
46929
46930 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46931 PyObject *resultobj = 0;
46932 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46933 int result;
46934 void *argp1 = 0 ;
46935 int res1 = 0 ;
46936 PyObject *swig_obj[1] ;
46937
46938 if (!args) SWIG_fail;
46939 swig_obj[0] = args;
46940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46941 if (!SWIG_IsOK(res1)) {
46942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46943 }
46944 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46945 {
46946 PyThreadState* __tstate = wxPyBeginAllowThreads();
46947 result = (int)(arg1)->GetProportion();
46948 wxPyEndAllowThreads(__tstate);
46949 if (PyErr_Occurred()) SWIG_fail;
46950 }
46951 resultobj = SWIG_From_int(static_cast< int >(result));
46952 return resultobj;
46953 fail:
46954 return NULL;
46955 }
46956
46957
46958 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46959 PyObject *resultobj = 0;
46960 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46961 int arg2 ;
46962 void *argp1 = 0 ;
46963 int res1 = 0 ;
46964 int val2 ;
46965 int ecode2 = 0 ;
46966 PyObject * obj0 = 0 ;
46967 PyObject * obj1 = 0 ;
46968 char * kwnames[] = {
46969 (char *) "self",(char *) "flag", NULL
46970 };
46971
46972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46974 if (!SWIG_IsOK(res1)) {
46975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46976 }
46977 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46978 ecode2 = SWIG_AsVal_int(obj1, &val2);
46979 if (!SWIG_IsOK(ecode2)) {
46980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46981 }
46982 arg2 = static_cast< int >(val2);
46983 {
46984 PyThreadState* __tstate = wxPyBeginAllowThreads();
46985 (arg1)->SetFlag(arg2);
46986 wxPyEndAllowThreads(__tstate);
46987 if (PyErr_Occurred()) SWIG_fail;
46988 }
46989 resultobj = SWIG_Py_Void();
46990 return resultobj;
46991 fail:
46992 return NULL;
46993 }
46994
46995
46996 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46997 PyObject *resultobj = 0;
46998 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46999 int result;
47000 void *argp1 = 0 ;
47001 int res1 = 0 ;
47002 PyObject *swig_obj[1] ;
47003
47004 if (!args) SWIG_fail;
47005 swig_obj[0] = args;
47006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47007 if (!SWIG_IsOK(res1)) {
47008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47009 }
47010 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47011 {
47012 PyThreadState* __tstate = wxPyBeginAllowThreads();
47013 result = (int)(arg1)->GetFlag();
47014 wxPyEndAllowThreads(__tstate);
47015 if (PyErr_Occurred()) SWIG_fail;
47016 }
47017 resultobj = SWIG_From_int(static_cast< int >(result));
47018 return resultobj;
47019 fail:
47020 return NULL;
47021 }
47022
47023
47024 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47025 PyObject *resultobj = 0;
47026 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47027 int arg2 ;
47028 void *argp1 = 0 ;
47029 int res1 = 0 ;
47030 int val2 ;
47031 int ecode2 = 0 ;
47032 PyObject * obj0 = 0 ;
47033 PyObject * obj1 = 0 ;
47034 char * kwnames[] = {
47035 (char *) "self",(char *) "border", NULL
47036 };
47037
47038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
47039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47040 if (!SWIG_IsOK(res1)) {
47041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47042 }
47043 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47044 ecode2 = SWIG_AsVal_int(obj1, &val2);
47045 if (!SWIG_IsOK(ecode2)) {
47046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
47047 }
47048 arg2 = static_cast< int >(val2);
47049 {
47050 PyThreadState* __tstate = wxPyBeginAllowThreads();
47051 (arg1)->SetBorder(arg2);
47052 wxPyEndAllowThreads(__tstate);
47053 if (PyErr_Occurred()) SWIG_fail;
47054 }
47055 resultobj = SWIG_Py_Void();
47056 return resultobj;
47057 fail:
47058 return NULL;
47059 }
47060
47061
47062 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47063 PyObject *resultobj = 0;
47064 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47065 int result;
47066 void *argp1 = 0 ;
47067 int res1 = 0 ;
47068 PyObject *swig_obj[1] ;
47069
47070 if (!args) SWIG_fail;
47071 swig_obj[0] = args;
47072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47073 if (!SWIG_IsOK(res1)) {
47074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47075 }
47076 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47077 {
47078 PyThreadState* __tstate = wxPyBeginAllowThreads();
47079 result = (int)(arg1)->GetBorder();
47080 wxPyEndAllowThreads(__tstate);
47081 if (PyErr_Occurred()) SWIG_fail;
47082 }
47083 resultobj = SWIG_From_int(static_cast< int >(result));
47084 return resultobj;
47085 fail:
47086 return NULL;
47087 }
47088
47089
47090 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47091 PyObject *resultobj = 0;
47092 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47093 wxWindow *result = 0 ;
47094 void *argp1 = 0 ;
47095 int res1 = 0 ;
47096 PyObject *swig_obj[1] ;
47097
47098 if (!args) SWIG_fail;
47099 swig_obj[0] = args;
47100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47101 if (!SWIG_IsOK(res1)) {
47102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47103 }
47104 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47105 {
47106 PyThreadState* __tstate = wxPyBeginAllowThreads();
47107 result = (wxWindow *)(arg1)->GetWindow();
47108 wxPyEndAllowThreads(__tstate);
47109 if (PyErr_Occurred()) SWIG_fail;
47110 }
47111 {
47112 resultobj = wxPyMake_wxObject(result, 0);
47113 }
47114 return resultobj;
47115 fail:
47116 return NULL;
47117 }
47118
47119
47120 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47121 PyObject *resultobj = 0;
47122 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47123 wxWindow *arg2 = (wxWindow *) 0 ;
47124 void *argp1 = 0 ;
47125 int res1 = 0 ;
47126 void *argp2 = 0 ;
47127 int res2 = 0 ;
47128 PyObject * obj0 = 0 ;
47129 PyObject * obj1 = 0 ;
47130 char * kwnames[] = {
47131 (char *) "self",(char *) "window", NULL
47132 };
47133
47134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47136 if (!SWIG_IsOK(res1)) {
47137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47138 }
47139 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47140 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47141 if (!SWIG_IsOK(res2)) {
47142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47143 }
47144 arg2 = reinterpret_cast< wxWindow * >(argp2);
47145 {
47146 PyThreadState* __tstate = wxPyBeginAllowThreads();
47147 (arg1)->SetWindow(arg2);
47148 wxPyEndAllowThreads(__tstate);
47149 if (PyErr_Occurred()) SWIG_fail;
47150 }
47151 resultobj = SWIG_Py_Void();
47152 return resultobj;
47153 fail:
47154 return NULL;
47155 }
47156
47157
47158 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47159 PyObject *resultobj = 0;
47160 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47161 wxSizer *result = 0 ;
47162 void *argp1 = 0 ;
47163 int res1 = 0 ;
47164 PyObject *swig_obj[1] ;
47165
47166 if (!args) SWIG_fail;
47167 swig_obj[0] = args;
47168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47169 if (!SWIG_IsOK(res1)) {
47170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47171 }
47172 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47173 {
47174 PyThreadState* __tstate = wxPyBeginAllowThreads();
47175 result = (wxSizer *)(arg1)->GetSizer();
47176 wxPyEndAllowThreads(__tstate);
47177 if (PyErr_Occurred()) SWIG_fail;
47178 }
47179 {
47180 resultobj = wxPyMake_wxObject(result, (bool)0);
47181 }
47182 return resultobj;
47183 fail:
47184 return NULL;
47185 }
47186
47187
47188 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47189 PyObject *resultobj = 0;
47190 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47191 wxSizer *arg2 = (wxSizer *) 0 ;
47192 void *argp1 = 0 ;
47193 int res1 = 0 ;
47194 int res2 = 0 ;
47195 PyObject * obj0 = 0 ;
47196 PyObject * obj1 = 0 ;
47197 char * kwnames[] = {
47198 (char *) "self",(char *) "sizer", NULL
47199 };
47200
47201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47203 if (!SWIG_IsOK(res1)) {
47204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47205 }
47206 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47207 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47208 if (!SWIG_IsOK(res2)) {
47209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47210 }
47211 {
47212 PyThreadState* __tstate = wxPyBeginAllowThreads();
47213 (arg1)->SetSizer(arg2);
47214 wxPyEndAllowThreads(__tstate);
47215 if (PyErr_Occurred()) SWIG_fail;
47216 }
47217 resultobj = SWIG_Py_Void();
47218 return resultobj;
47219 fail:
47220 return NULL;
47221 }
47222
47223
47224 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47225 PyObject *resultobj = 0;
47226 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47227 wxSize *result = 0 ;
47228 void *argp1 = 0 ;
47229 int res1 = 0 ;
47230 PyObject *swig_obj[1] ;
47231
47232 if (!args) SWIG_fail;
47233 swig_obj[0] = args;
47234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47235 if (!SWIG_IsOK(res1)) {
47236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47237 }
47238 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47239 {
47240 PyThreadState* __tstate = wxPyBeginAllowThreads();
47241 {
47242 wxSize const &_result_ref = (arg1)->GetSpacer();
47243 result = (wxSize *) &_result_ref;
47244 }
47245 wxPyEndAllowThreads(__tstate);
47246 if (PyErr_Occurred()) SWIG_fail;
47247 }
47248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
47249 return resultobj;
47250 fail:
47251 return NULL;
47252 }
47253
47254
47255 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47256 PyObject *resultobj = 0;
47257 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47258 wxSize *arg2 = 0 ;
47259 void *argp1 = 0 ;
47260 int res1 = 0 ;
47261 wxSize temp2 ;
47262 PyObject * obj0 = 0 ;
47263 PyObject * obj1 = 0 ;
47264 char * kwnames[] = {
47265 (char *) "self",(char *) "size", NULL
47266 };
47267
47268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
47269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47270 if (!SWIG_IsOK(res1)) {
47271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47272 }
47273 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47274 {
47275 arg2 = &temp2;
47276 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47277 }
47278 {
47279 PyThreadState* __tstate = wxPyBeginAllowThreads();
47280 (arg1)->SetSpacer((wxSize const &)*arg2);
47281 wxPyEndAllowThreads(__tstate);
47282 if (PyErr_Occurred()) SWIG_fail;
47283 }
47284 resultobj = SWIG_Py_Void();
47285 return resultobj;
47286 fail:
47287 return NULL;
47288 }
47289
47290
47291 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47292 PyObject *resultobj = 0;
47293 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47294 bool arg2 ;
47295 void *argp1 = 0 ;
47296 int res1 = 0 ;
47297 bool val2 ;
47298 int ecode2 = 0 ;
47299 PyObject * obj0 = 0 ;
47300 PyObject * obj1 = 0 ;
47301 char * kwnames[] = {
47302 (char *) "self",(char *) "show", NULL
47303 };
47304
47305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
47306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47307 if (!SWIG_IsOK(res1)) {
47308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47309 }
47310 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47311 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47312 if (!SWIG_IsOK(ecode2)) {
47313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
47314 }
47315 arg2 = static_cast< bool >(val2);
47316 {
47317 PyThreadState* __tstate = wxPyBeginAllowThreads();
47318 (arg1)->Show(arg2);
47319 wxPyEndAllowThreads(__tstate);
47320 if (PyErr_Occurred()) SWIG_fail;
47321 }
47322 resultobj = SWIG_Py_Void();
47323 return resultobj;
47324 fail:
47325 return NULL;
47326 }
47327
47328
47329 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47330 PyObject *resultobj = 0;
47331 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47332 bool result;
47333 void *argp1 = 0 ;
47334 int res1 = 0 ;
47335 PyObject *swig_obj[1] ;
47336
47337 if (!args) SWIG_fail;
47338 swig_obj[0] = args;
47339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47340 if (!SWIG_IsOK(res1)) {
47341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47342 }
47343 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47344 {
47345 PyThreadState* __tstate = wxPyBeginAllowThreads();
47346 result = (bool)(arg1)->IsShown();
47347 wxPyEndAllowThreads(__tstate);
47348 if (PyErr_Occurred()) SWIG_fail;
47349 }
47350 {
47351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47352 }
47353 return resultobj;
47354 fail:
47355 return NULL;
47356 }
47357
47358
47359 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47360 PyObject *resultobj = 0;
47361 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47362 wxPoint result;
47363 void *argp1 = 0 ;
47364 int res1 = 0 ;
47365 PyObject *swig_obj[1] ;
47366
47367 if (!args) SWIG_fail;
47368 swig_obj[0] = args;
47369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47370 if (!SWIG_IsOK(res1)) {
47371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47372 }
47373 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47374 {
47375 PyThreadState* __tstate = wxPyBeginAllowThreads();
47376 result = (arg1)->GetPosition();
47377 wxPyEndAllowThreads(__tstate);
47378 if (PyErr_Occurred()) SWIG_fail;
47379 }
47380 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47381 return resultobj;
47382 fail:
47383 return NULL;
47384 }
47385
47386
47387 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47388 PyObject *resultobj = 0;
47389 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47390 PyObject *result = 0 ;
47391 void *argp1 = 0 ;
47392 int res1 = 0 ;
47393 PyObject *swig_obj[1] ;
47394
47395 if (!args) SWIG_fail;
47396 swig_obj[0] = args;
47397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47398 if (!SWIG_IsOK(res1)) {
47399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47400 }
47401 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47402 {
47403 PyThreadState* __tstate = wxPyBeginAllowThreads();
47404 result = (PyObject *)wxSizerItem_GetUserData(arg1);
47405 wxPyEndAllowThreads(__tstate);
47406 if (PyErr_Occurred()) SWIG_fail;
47407 }
47408 resultobj = result;
47409 return resultobj;
47410 fail:
47411 return NULL;
47412 }
47413
47414
47415 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47416 PyObject *resultobj = 0;
47417 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47418 PyObject *arg2 = (PyObject *) 0 ;
47419 void *argp1 = 0 ;
47420 int res1 = 0 ;
47421 PyObject * obj0 = 0 ;
47422 PyObject * obj1 = 0 ;
47423 char * kwnames[] = {
47424 (char *) "self",(char *) "userData", NULL
47425 };
47426
47427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47429 if (!SWIG_IsOK(res1)) {
47430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47431 }
47432 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47433 arg2 = obj1;
47434 {
47435 PyThreadState* __tstate = wxPyBeginAllowThreads();
47436 wxSizerItem_SetUserData(arg1,arg2);
47437 wxPyEndAllowThreads(__tstate);
47438 if (PyErr_Occurred()) SWIG_fail;
47439 }
47440 resultobj = SWIG_Py_Void();
47441 return resultobj;
47442 fail:
47443 return NULL;
47444 }
47445
47446
47447 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47448 PyObject *obj;
47449 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47450 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47451 return SWIG_Py_Void();
47452 }
47453
47454 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47455 return SWIG_Python_InitShadowInstance(args);
47456 }
47457
47458 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47459 PyObject *resultobj = 0;
47460 wxSizer *arg1 = (wxSizer *) 0 ;
47461 void *argp1 = 0 ;
47462 int res1 = 0 ;
47463 PyObject *swig_obj[1] ;
47464
47465 if (!args) SWIG_fail;
47466 swig_obj[0] = args;
47467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47468 if (!SWIG_IsOK(res1)) {
47469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47470 }
47471 arg1 = reinterpret_cast< wxSizer * >(argp1);
47472 {
47473 PyThreadState* __tstate = wxPyBeginAllowThreads();
47474 delete arg1;
47475
47476 wxPyEndAllowThreads(__tstate);
47477 if (PyErr_Occurred()) SWIG_fail;
47478 }
47479 resultobj = SWIG_Py_Void();
47480 return resultobj;
47481 fail:
47482 return NULL;
47483 }
47484
47485
47486 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47487 PyObject *resultobj = 0;
47488 wxSizer *arg1 = (wxSizer *) 0 ;
47489 PyObject *arg2 = (PyObject *) 0 ;
47490 void *argp1 = 0 ;
47491 int res1 = 0 ;
47492 PyObject * obj0 = 0 ;
47493 PyObject * obj1 = 0 ;
47494 char * kwnames[] = {
47495 (char *) "self",(char *) "_self", NULL
47496 };
47497
47498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47500 if (!SWIG_IsOK(res1)) {
47501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47502 }
47503 arg1 = reinterpret_cast< wxSizer * >(argp1);
47504 arg2 = obj1;
47505 {
47506 PyThreadState* __tstate = wxPyBeginAllowThreads();
47507 wxSizer__setOORInfo(arg1,arg2);
47508 wxPyEndAllowThreads(__tstate);
47509 if (PyErr_Occurred()) SWIG_fail;
47510 }
47511 resultobj = SWIG_Py_Void();
47512 return resultobj;
47513 fail:
47514 return NULL;
47515 }
47516
47517
47518 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47519 PyObject *resultobj = 0;
47520 wxSizer *arg1 = (wxSizer *) 0 ;
47521 PyObject *arg2 = (PyObject *) 0 ;
47522 int arg3 = (int) 0 ;
47523 int arg4 = (int) 0 ;
47524 int arg5 = (int) 0 ;
47525 PyObject *arg6 = (PyObject *) NULL ;
47526 wxSizerItem *result = 0 ;
47527 void *argp1 = 0 ;
47528 int res1 = 0 ;
47529 int val3 ;
47530 int ecode3 = 0 ;
47531 int val4 ;
47532 int ecode4 = 0 ;
47533 int val5 ;
47534 int ecode5 = 0 ;
47535 PyObject * obj0 = 0 ;
47536 PyObject * obj1 = 0 ;
47537 PyObject * obj2 = 0 ;
47538 PyObject * obj3 = 0 ;
47539 PyObject * obj4 = 0 ;
47540 PyObject * obj5 = 0 ;
47541 char * kwnames[] = {
47542 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47543 };
47544
47545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47547 if (!SWIG_IsOK(res1)) {
47548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47549 }
47550 arg1 = reinterpret_cast< wxSizer * >(argp1);
47551 arg2 = obj1;
47552 if (obj2) {
47553 ecode3 = SWIG_AsVal_int(obj2, &val3);
47554 if (!SWIG_IsOK(ecode3)) {
47555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47556 }
47557 arg3 = static_cast< int >(val3);
47558 }
47559 if (obj3) {
47560 ecode4 = SWIG_AsVal_int(obj3, &val4);
47561 if (!SWIG_IsOK(ecode4)) {
47562 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47563 }
47564 arg4 = static_cast< int >(val4);
47565 }
47566 if (obj4) {
47567 ecode5 = SWIG_AsVal_int(obj4, &val5);
47568 if (!SWIG_IsOK(ecode5)) {
47569 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47570 }
47571 arg5 = static_cast< int >(val5);
47572 }
47573 if (obj5) {
47574 arg6 = obj5;
47575 }
47576 {
47577 PyThreadState* __tstate = wxPyBeginAllowThreads();
47578 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47579 wxPyEndAllowThreads(__tstate);
47580 if (PyErr_Occurred()) SWIG_fail;
47581 }
47582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47583 return resultobj;
47584 fail:
47585 return NULL;
47586 }
47587
47588
47589 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47590 PyObject *resultobj = 0;
47591 wxSizer *arg1 = (wxSizer *) 0 ;
47592 int arg2 ;
47593 PyObject *arg3 = (PyObject *) 0 ;
47594 int arg4 = (int) 0 ;
47595 int arg5 = (int) 0 ;
47596 int arg6 = (int) 0 ;
47597 PyObject *arg7 = (PyObject *) NULL ;
47598 wxSizerItem *result = 0 ;
47599 void *argp1 = 0 ;
47600 int res1 = 0 ;
47601 int val2 ;
47602 int ecode2 = 0 ;
47603 int val4 ;
47604 int ecode4 = 0 ;
47605 int val5 ;
47606 int ecode5 = 0 ;
47607 int val6 ;
47608 int ecode6 = 0 ;
47609 PyObject * obj0 = 0 ;
47610 PyObject * obj1 = 0 ;
47611 PyObject * obj2 = 0 ;
47612 PyObject * obj3 = 0 ;
47613 PyObject * obj4 = 0 ;
47614 PyObject * obj5 = 0 ;
47615 PyObject * obj6 = 0 ;
47616 char * kwnames[] = {
47617 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47618 };
47619
47620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47622 if (!SWIG_IsOK(res1)) {
47623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47624 }
47625 arg1 = reinterpret_cast< wxSizer * >(argp1);
47626 ecode2 = SWIG_AsVal_int(obj1, &val2);
47627 if (!SWIG_IsOK(ecode2)) {
47628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47629 }
47630 arg2 = static_cast< int >(val2);
47631 arg3 = obj2;
47632 if (obj3) {
47633 ecode4 = SWIG_AsVal_int(obj3, &val4);
47634 if (!SWIG_IsOK(ecode4)) {
47635 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47636 }
47637 arg4 = static_cast< int >(val4);
47638 }
47639 if (obj4) {
47640 ecode5 = SWIG_AsVal_int(obj4, &val5);
47641 if (!SWIG_IsOK(ecode5)) {
47642 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47643 }
47644 arg5 = static_cast< int >(val5);
47645 }
47646 if (obj5) {
47647 ecode6 = SWIG_AsVal_int(obj5, &val6);
47648 if (!SWIG_IsOK(ecode6)) {
47649 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47650 }
47651 arg6 = static_cast< int >(val6);
47652 }
47653 if (obj6) {
47654 arg7 = obj6;
47655 }
47656 {
47657 PyThreadState* __tstate = wxPyBeginAllowThreads();
47658 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47659 wxPyEndAllowThreads(__tstate);
47660 if (PyErr_Occurred()) SWIG_fail;
47661 }
47662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47663 return resultobj;
47664 fail:
47665 return NULL;
47666 }
47667
47668
47669 SWIGINTERN PyObject *_wrap_Sizer_Prepend(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_Prepend",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_Prepend" "', 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_Prepend" "', 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_Prepend" "', 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_Prepend" "', 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_Prepend(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_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47741 PyObject *resultobj = 0;
47742 wxSizer *arg1 = (wxSizer *) 0 ;
47743 PyObject *arg2 = (PyObject *) 0 ;
47744 bool result;
47745 void *argp1 = 0 ;
47746 int res1 = 0 ;
47747 PyObject * obj0 = 0 ;
47748 PyObject * obj1 = 0 ;
47749 char * kwnames[] = {
47750 (char *) "self",(char *) "item", NULL
47751 };
47752
47753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47755 if (!SWIG_IsOK(res1)) {
47756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47757 }
47758 arg1 = reinterpret_cast< wxSizer * >(argp1);
47759 arg2 = obj1;
47760 {
47761 PyThreadState* __tstate = wxPyBeginAllowThreads();
47762 result = (bool)wxSizer_Remove(arg1,arg2);
47763 wxPyEndAllowThreads(__tstate);
47764 if (PyErr_Occurred()) SWIG_fail;
47765 }
47766 {
47767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47768 }
47769 return resultobj;
47770 fail:
47771 return NULL;
47772 }
47773
47774
47775 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47776 PyObject *resultobj = 0;
47777 wxSizer *arg1 = (wxSizer *) 0 ;
47778 PyObject *arg2 = (PyObject *) 0 ;
47779 bool result;
47780 void *argp1 = 0 ;
47781 int res1 = 0 ;
47782 PyObject * obj0 = 0 ;
47783 PyObject * obj1 = 0 ;
47784 char * kwnames[] = {
47785 (char *) "self",(char *) "item", NULL
47786 };
47787
47788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47790 if (!SWIG_IsOK(res1)) {
47791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47792 }
47793 arg1 = reinterpret_cast< wxSizer * >(argp1);
47794 arg2 = obj1;
47795 {
47796 PyThreadState* __tstate = wxPyBeginAllowThreads();
47797 result = (bool)wxSizer_Detach(arg1,arg2);
47798 wxPyEndAllowThreads(__tstate);
47799 if (PyErr_Occurred()) SWIG_fail;
47800 }
47801 {
47802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47803 }
47804 return resultobj;
47805 fail:
47806 return NULL;
47807 }
47808
47809
47810 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47811 PyObject *resultobj = 0;
47812 wxSizer *arg1 = (wxSizer *) 0 ;
47813 PyObject *arg2 = (PyObject *) 0 ;
47814 wxSizerItem *result = 0 ;
47815 void *argp1 = 0 ;
47816 int res1 = 0 ;
47817 PyObject * obj0 = 0 ;
47818 PyObject * obj1 = 0 ;
47819 char * kwnames[] = {
47820 (char *) "self",(char *) "item", NULL
47821 };
47822
47823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47825 if (!SWIG_IsOK(res1)) {
47826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47827 }
47828 arg1 = reinterpret_cast< wxSizer * >(argp1);
47829 arg2 = obj1;
47830 {
47831 PyThreadState* __tstate = wxPyBeginAllowThreads();
47832 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47833 wxPyEndAllowThreads(__tstate);
47834 if (PyErr_Occurred()) SWIG_fail;
47835 }
47836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47837 return resultobj;
47838 fail:
47839 return NULL;
47840 }
47841
47842
47843 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47844 PyObject *resultobj = 0;
47845 wxSizer *arg1 = (wxSizer *) 0 ;
47846 PyObject *arg2 = (PyObject *) 0 ;
47847 wxSize *arg3 = 0 ;
47848 void *argp1 = 0 ;
47849 int res1 = 0 ;
47850 wxSize temp3 ;
47851 PyObject * obj0 = 0 ;
47852 PyObject * obj1 = 0 ;
47853 PyObject * obj2 = 0 ;
47854 char * kwnames[] = {
47855 (char *) "self",(char *) "item",(char *) "size", NULL
47856 };
47857
47858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47860 if (!SWIG_IsOK(res1)) {
47861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47862 }
47863 arg1 = reinterpret_cast< wxSizer * >(argp1);
47864 arg2 = obj1;
47865 {
47866 arg3 = &temp3;
47867 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47868 }
47869 {
47870 PyThreadState* __tstate = wxPyBeginAllowThreads();
47871 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47872 wxPyEndAllowThreads(__tstate);
47873 if (PyErr_Occurred()) SWIG_fail;
47874 }
47875 resultobj = SWIG_Py_Void();
47876 return resultobj;
47877 fail:
47878 return NULL;
47879 }
47880
47881
47882 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47883 PyObject *resultobj = 0;
47884 wxSizer *arg1 = (wxSizer *) 0 ;
47885 wxWindow *arg2 = (wxWindow *) 0 ;
47886 wxWindow *arg3 = (wxWindow *) 0 ;
47887 bool arg4 = (bool) false ;
47888 bool result;
47889 void *argp1 = 0 ;
47890 int res1 = 0 ;
47891 void *argp2 = 0 ;
47892 int res2 = 0 ;
47893 void *argp3 = 0 ;
47894 int res3 = 0 ;
47895 bool val4 ;
47896 int ecode4 = 0 ;
47897 PyObject * obj0 = 0 ;
47898 PyObject * obj1 = 0 ;
47899 PyObject * obj2 = 0 ;
47900 PyObject * obj3 = 0 ;
47901 char * kwnames[] = {
47902 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
47903 };
47904
47905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47907 if (!SWIG_IsOK(res1)) {
47908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
47909 }
47910 arg1 = reinterpret_cast< wxSizer * >(argp1);
47911 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47912 if (!SWIG_IsOK(res2)) {
47913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
47914 }
47915 arg2 = reinterpret_cast< wxWindow * >(argp2);
47916 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
47917 if (!SWIG_IsOK(res3)) {
47918 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
47919 }
47920 arg3 = reinterpret_cast< wxWindow * >(argp3);
47921 if (obj3) {
47922 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47923 if (!SWIG_IsOK(ecode4)) {
47924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
47925 }
47926 arg4 = static_cast< bool >(val4);
47927 }
47928 {
47929 PyThreadState* __tstate = wxPyBeginAllowThreads();
47930 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47931 wxPyEndAllowThreads(__tstate);
47932 if (PyErr_Occurred()) SWIG_fail;
47933 }
47934 {
47935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47936 }
47937 return resultobj;
47938 fail:
47939 return NULL;
47940 }
47941
47942
47943 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47944 PyObject *resultobj = 0;
47945 wxSizer *arg1 = (wxSizer *) 0 ;
47946 wxSizer *arg2 = (wxSizer *) 0 ;
47947 wxSizer *arg3 = (wxSizer *) 0 ;
47948 bool arg4 = (bool) false ;
47949 bool result;
47950 void *argp1 = 0 ;
47951 int res1 = 0 ;
47952 void *argp2 = 0 ;
47953 int res2 = 0 ;
47954 void *argp3 = 0 ;
47955 int res3 = 0 ;
47956 bool val4 ;
47957 int ecode4 = 0 ;
47958 PyObject * obj0 = 0 ;
47959 PyObject * obj1 = 0 ;
47960 PyObject * obj2 = 0 ;
47961 PyObject * obj3 = 0 ;
47962 char * kwnames[] = {
47963 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
47964 };
47965
47966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47968 if (!SWIG_IsOK(res1)) {
47969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47970 }
47971 arg1 = reinterpret_cast< wxSizer * >(argp1);
47972 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
47973 if (!SWIG_IsOK(res2)) {
47974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47975 }
47976 arg2 = reinterpret_cast< wxSizer * >(argp2);
47977 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
47978 if (!SWIG_IsOK(res3)) {
47979 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
47980 }
47981 arg3 = reinterpret_cast< wxSizer * >(argp3);
47982 if (obj3) {
47983 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47984 if (!SWIG_IsOK(ecode4)) {
47985 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
47986 }
47987 arg4 = static_cast< bool >(val4);
47988 }
47989 {
47990 PyThreadState* __tstate = wxPyBeginAllowThreads();
47991 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47992 wxPyEndAllowThreads(__tstate);
47993 if (PyErr_Occurred()) SWIG_fail;
47994 }
47995 {
47996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47997 }
47998 return resultobj;
47999 fail:
48000 return NULL;
48001 }
48002
48003
48004 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48005 PyObject *resultobj = 0;
48006 wxSizer *arg1 = (wxSizer *) 0 ;
48007 size_t arg2 ;
48008 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48009 bool result;
48010 void *argp1 = 0 ;
48011 int res1 = 0 ;
48012 size_t val2 ;
48013 int ecode2 = 0 ;
48014 void *argp3 = 0 ;
48015 int res3 = 0 ;
48016 PyObject * obj0 = 0 ;
48017 PyObject * obj1 = 0 ;
48018 PyObject * obj2 = 0 ;
48019 char * kwnames[] = {
48020 (char *) "self",(char *) "index",(char *) "newitem", NULL
48021 };
48022
48023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48025 if (!SWIG_IsOK(res1)) {
48026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48027 }
48028 arg1 = reinterpret_cast< wxSizer * >(argp1);
48029 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48030 if (!SWIG_IsOK(ecode2)) {
48031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
48032 }
48033 arg2 = static_cast< size_t >(val2);
48034 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48035 if (!SWIG_IsOK(res3)) {
48036 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48037 }
48038 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
48039 {
48040 PyThreadState* __tstate = wxPyBeginAllowThreads();
48041 result = (bool)(arg1)->Replace(arg2,arg3);
48042 wxPyEndAllowThreads(__tstate);
48043 if (PyErr_Occurred()) SWIG_fail;
48044 }
48045 {
48046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48047 }
48048 return resultobj;
48049 fail:
48050 return NULL;
48051 }
48052
48053
48054 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48055 PyObject *resultobj = 0;
48056 wxSizer *arg1 = (wxSizer *) 0 ;
48057 wxWindow *arg2 = (wxWindow *) 0 ;
48058 void *argp1 = 0 ;
48059 int res1 = 0 ;
48060 void *argp2 = 0 ;
48061 int res2 = 0 ;
48062 PyObject * obj0 = 0 ;
48063 PyObject * obj1 = 0 ;
48064 char * kwnames[] = {
48065 (char *) "self",(char *) "window", NULL
48066 };
48067
48068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
48069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48070 if (!SWIG_IsOK(res1)) {
48071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
48072 }
48073 arg1 = reinterpret_cast< wxSizer * >(argp1);
48074 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48075 if (!SWIG_IsOK(res2)) {
48076 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
48077 }
48078 arg2 = reinterpret_cast< wxWindow * >(argp2);
48079 {
48080 PyThreadState* __tstate = wxPyBeginAllowThreads();
48081 (arg1)->SetContainingWindow(arg2);
48082 wxPyEndAllowThreads(__tstate);
48083 if (PyErr_Occurred()) SWIG_fail;
48084 }
48085 resultobj = SWIG_Py_Void();
48086 return resultobj;
48087 fail:
48088 return NULL;
48089 }
48090
48091
48092 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48093 PyObject *resultobj = 0;
48094 wxSizer *arg1 = (wxSizer *) 0 ;
48095 wxWindow *result = 0 ;
48096 void *argp1 = 0 ;
48097 int res1 = 0 ;
48098 PyObject *swig_obj[1] ;
48099
48100 if (!args) SWIG_fail;
48101 swig_obj[0] = args;
48102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48103 if (!SWIG_IsOK(res1)) {
48104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
48105 }
48106 arg1 = reinterpret_cast< wxSizer * >(argp1);
48107 {
48108 PyThreadState* __tstate = wxPyBeginAllowThreads();
48109 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
48110 wxPyEndAllowThreads(__tstate);
48111 if (PyErr_Occurred()) SWIG_fail;
48112 }
48113 {
48114 resultobj = wxPyMake_wxObject(result, 0);
48115 }
48116 return resultobj;
48117 fail:
48118 return NULL;
48119 }
48120
48121
48122 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48123 PyObject *resultobj = 0;
48124 wxSizer *arg1 = (wxSizer *) 0 ;
48125 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48126 wxSizerItem *result = 0 ;
48127 void *argp1 = 0 ;
48128 int res1 = 0 ;
48129 int res2 = 0 ;
48130 PyObject * obj0 = 0 ;
48131 PyObject * obj1 = 0 ;
48132 char * kwnames[] = {
48133 (char *) "self",(char *) "item", NULL
48134 };
48135
48136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
48137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48138 if (!SWIG_IsOK(res1)) {
48139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48140 }
48141 arg1 = reinterpret_cast< wxSizer * >(argp1);
48142 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48143 if (!SWIG_IsOK(res2)) {
48144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48145 }
48146 {
48147 PyThreadState* __tstate = wxPyBeginAllowThreads();
48148 result = (wxSizerItem *)(arg1)->Add(arg2);
48149 wxPyEndAllowThreads(__tstate);
48150 if (PyErr_Occurred()) SWIG_fail;
48151 }
48152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48153 return resultobj;
48154 fail:
48155 return NULL;
48156 }
48157
48158
48159 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48160 PyObject *resultobj = 0;
48161 wxSizer *arg1 = (wxSizer *) 0 ;
48162 size_t arg2 ;
48163 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48164 wxSizerItem *result = 0 ;
48165 void *argp1 = 0 ;
48166 int res1 = 0 ;
48167 size_t val2 ;
48168 int ecode2 = 0 ;
48169 int res3 = 0 ;
48170 PyObject * obj0 = 0 ;
48171 PyObject * obj1 = 0 ;
48172 PyObject * obj2 = 0 ;
48173 char * kwnames[] = {
48174 (char *) "self",(char *) "index",(char *) "item", NULL
48175 };
48176
48177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48179 if (!SWIG_IsOK(res1)) {
48180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48181 }
48182 arg1 = reinterpret_cast< wxSizer * >(argp1);
48183 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48184 if (!SWIG_IsOK(ecode2)) {
48185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
48186 }
48187 arg2 = static_cast< size_t >(val2);
48188 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48189 if (!SWIG_IsOK(res3)) {
48190 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48191 }
48192 {
48193 PyThreadState* __tstate = wxPyBeginAllowThreads();
48194 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
48195 wxPyEndAllowThreads(__tstate);
48196 if (PyErr_Occurred()) SWIG_fail;
48197 }
48198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48199 return resultobj;
48200 fail:
48201 return NULL;
48202 }
48203
48204
48205 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48206 PyObject *resultobj = 0;
48207 wxSizer *arg1 = (wxSizer *) 0 ;
48208 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48209 wxSizerItem *result = 0 ;
48210 void *argp1 = 0 ;
48211 int res1 = 0 ;
48212 int res2 = 0 ;
48213 PyObject * obj0 = 0 ;
48214 PyObject * obj1 = 0 ;
48215 char * kwnames[] = {
48216 (char *) "self",(char *) "item", NULL
48217 };
48218
48219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",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_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48223 }
48224 arg1 = reinterpret_cast< wxSizer * >(argp1);
48225 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48226 if (!SWIG_IsOK(res2)) {
48227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48228 }
48229 {
48230 PyThreadState* __tstate = wxPyBeginAllowThreads();
48231 result = (wxSizerItem *)(arg1)->Prepend(arg2);
48232 wxPyEndAllowThreads(__tstate);
48233 if (PyErr_Occurred()) SWIG_fail;
48234 }
48235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48236 return resultobj;
48237 fail:
48238 return NULL;
48239 }
48240
48241
48242 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48243 PyObject *resultobj = 0;
48244 wxSizer *arg1 = (wxSizer *) 0 ;
48245 int arg2 ;
48246 int arg3 ;
48247 int arg4 ;
48248 int arg5 ;
48249 void *argp1 = 0 ;
48250 int res1 = 0 ;
48251 int val2 ;
48252 int ecode2 = 0 ;
48253 int val3 ;
48254 int ecode3 = 0 ;
48255 int val4 ;
48256 int ecode4 = 0 ;
48257 int val5 ;
48258 int ecode5 = 0 ;
48259 PyObject * obj0 = 0 ;
48260 PyObject * obj1 = 0 ;
48261 PyObject * obj2 = 0 ;
48262 PyObject * obj3 = 0 ;
48263 PyObject * obj4 = 0 ;
48264 char * kwnames[] = {
48265 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
48266 };
48267
48268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48270 if (!SWIG_IsOK(res1)) {
48271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
48272 }
48273 arg1 = reinterpret_cast< wxSizer * >(argp1);
48274 ecode2 = SWIG_AsVal_int(obj1, &val2);
48275 if (!SWIG_IsOK(ecode2)) {
48276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
48277 }
48278 arg2 = static_cast< int >(val2);
48279 ecode3 = SWIG_AsVal_int(obj2, &val3);
48280 if (!SWIG_IsOK(ecode3)) {
48281 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
48282 }
48283 arg3 = static_cast< int >(val3);
48284 ecode4 = SWIG_AsVal_int(obj3, &val4);
48285 if (!SWIG_IsOK(ecode4)) {
48286 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
48287 }
48288 arg4 = static_cast< int >(val4);
48289 ecode5 = SWIG_AsVal_int(obj4, &val5);
48290 if (!SWIG_IsOK(ecode5)) {
48291 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
48292 }
48293 arg5 = static_cast< int >(val5);
48294 {
48295 PyThreadState* __tstate = wxPyBeginAllowThreads();
48296 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
48297 wxPyEndAllowThreads(__tstate);
48298 if (PyErr_Occurred()) SWIG_fail;
48299 }
48300 resultobj = SWIG_Py_Void();
48301 return resultobj;
48302 fail:
48303 return NULL;
48304 }
48305
48306
48307 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48308 PyObject *resultobj = 0;
48309 wxSizer *arg1 = (wxSizer *) 0 ;
48310 wxSize *arg2 = 0 ;
48311 void *argp1 = 0 ;
48312 int res1 = 0 ;
48313 wxSize temp2 ;
48314 PyObject * obj0 = 0 ;
48315 PyObject * obj1 = 0 ;
48316 char * kwnames[] = {
48317 (char *) "self",(char *) "size", NULL
48318 };
48319
48320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
48321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48322 if (!SWIG_IsOK(res1)) {
48323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48324 }
48325 arg1 = reinterpret_cast< wxSizer * >(argp1);
48326 {
48327 arg2 = &temp2;
48328 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48329 }
48330 {
48331 PyThreadState* __tstate = wxPyBeginAllowThreads();
48332 (arg1)->SetMinSize((wxSize const &)*arg2);
48333 wxPyEndAllowThreads(__tstate);
48334 if (PyErr_Occurred()) SWIG_fail;
48335 }
48336 resultobj = SWIG_Py_Void();
48337 return resultobj;
48338 fail:
48339 return NULL;
48340 }
48341
48342
48343 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48344 PyObject *resultobj = 0;
48345 wxSizer *arg1 = (wxSizer *) 0 ;
48346 wxSize result;
48347 void *argp1 = 0 ;
48348 int res1 = 0 ;
48349 PyObject *swig_obj[1] ;
48350
48351 if (!args) SWIG_fail;
48352 swig_obj[0] = args;
48353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48354 if (!SWIG_IsOK(res1)) {
48355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48356 }
48357 arg1 = reinterpret_cast< wxSizer * >(argp1);
48358 {
48359 PyThreadState* __tstate = wxPyBeginAllowThreads();
48360 result = (arg1)->GetSize();
48361 wxPyEndAllowThreads(__tstate);
48362 if (PyErr_Occurred()) SWIG_fail;
48363 }
48364 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48365 return resultobj;
48366 fail:
48367 return NULL;
48368 }
48369
48370
48371 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48372 PyObject *resultobj = 0;
48373 wxSizer *arg1 = (wxSizer *) 0 ;
48374 wxPoint result;
48375 void *argp1 = 0 ;
48376 int res1 = 0 ;
48377 PyObject *swig_obj[1] ;
48378
48379 if (!args) SWIG_fail;
48380 swig_obj[0] = args;
48381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48382 if (!SWIG_IsOK(res1)) {
48383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
48384 }
48385 arg1 = reinterpret_cast< wxSizer * >(argp1);
48386 {
48387 PyThreadState* __tstate = wxPyBeginAllowThreads();
48388 result = (arg1)->GetPosition();
48389 wxPyEndAllowThreads(__tstate);
48390 if (PyErr_Occurred()) SWIG_fail;
48391 }
48392 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
48393 return resultobj;
48394 fail:
48395 return NULL;
48396 }
48397
48398
48399 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48400 PyObject *resultobj = 0;
48401 wxSizer *arg1 = (wxSizer *) 0 ;
48402 wxSize result;
48403 void *argp1 = 0 ;
48404 int res1 = 0 ;
48405 PyObject *swig_obj[1] ;
48406
48407 if (!args) SWIG_fail;
48408 swig_obj[0] = args;
48409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48410 if (!SWIG_IsOK(res1)) {
48411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48412 }
48413 arg1 = reinterpret_cast< wxSizer * >(argp1);
48414 {
48415 PyThreadState* __tstate = wxPyBeginAllowThreads();
48416 result = (arg1)->GetMinSize();
48417 wxPyEndAllowThreads(__tstate);
48418 if (PyErr_Occurred()) SWIG_fail;
48419 }
48420 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48421 return resultobj;
48422 fail:
48423 return NULL;
48424 }
48425
48426
48427 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48428 PyObject *resultobj = 0;
48429 wxSizer *arg1 = (wxSizer *) 0 ;
48430 void *argp1 = 0 ;
48431 int res1 = 0 ;
48432 PyObject *swig_obj[1] ;
48433
48434 if (!args) SWIG_fail;
48435 swig_obj[0] = args;
48436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48437 if (!SWIG_IsOK(res1)) {
48438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48439 }
48440 arg1 = reinterpret_cast< wxSizer * >(argp1);
48441 {
48442 PyThreadState* __tstate = wxPyBeginAllowThreads();
48443 (arg1)->RecalcSizes();
48444 wxPyEndAllowThreads(__tstate);
48445 if (PyErr_Occurred()) SWIG_fail;
48446 }
48447 resultobj = SWIG_Py_Void();
48448 return resultobj;
48449 fail:
48450 return NULL;
48451 }
48452
48453
48454 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48455 PyObject *resultobj = 0;
48456 wxSizer *arg1 = (wxSizer *) 0 ;
48457 wxSize result;
48458 void *argp1 = 0 ;
48459 int res1 = 0 ;
48460 PyObject *swig_obj[1] ;
48461
48462 if (!args) SWIG_fail;
48463 swig_obj[0] = args;
48464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48465 if (!SWIG_IsOK(res1)) {
48466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48467 }
48468 arg1 = reinterpret_cast< wxSizer * >(argp1);
48469 {
48470 PyThreadState* __tstate = wxPyBeginAllowThreads();
48471 result = (arg1)->CalcMin();
48472 wxPyEndAllowThreads(__tstate);
48473 if (PyErr_Occurred()) SWIG_fail;
48474 }
48475 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48476 return resultobj;
48477 fail:
48478 return NULL;
48479 }
48480
48481
48482 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48483 PyObject *resultobj = 0;
48484 wxSizer *arg1 = (wxSizer *) 0 ;
48485 void *argp1 = 0 ;
48486 int res1 = 0 ;
48487 PyObject *swig_obj[1] ;
48488
48489 if (!args) SWIG_fail;
48490 swig_obj[0] = args;
48491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48492 if (!SWIG_IsOK(res1)) {
48493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48494 }
48495 arg1 = reinterpret_cast< wxSizer * >(argp1);
48496 {
48497 PyThreadState* __tstate = wxPyBeginAllowThreads();
48498 (arg1)->Layout();
48499 wxPyEndAllowThreads(__tstate);
48500 if (PyErr_Occurred()) SWIG_fail;
48501 }
48502 resultobj = SWIG_Py_Void();
48503 return resultobj;
48504 fail:
48505 return NULL;
48506 }
48507
48508
48509 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48510 PyObject *resultobj = 0;
48511 wxSizer *arg1 = (wxSizer *) 0 ;
48512 wxWindow *arg2 = (wxWindow *) 0 ;
48513 wxSize result;
48514 void *argp1 = 0 ;
48515 int res1 = 0 ;
48516 void *argp2 = 0 ;
48517 int res2 = 0 ;
48518 PyObject * obj0 = 0 ;
48519 PyObject * obj1 = 0 ;
48520 char * kwnames[] = {
48521 (char *) "self",(char *) "window", NULL
48522 };
48523
48524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48526 if (!SWIG_IsOK(res1)) {
48527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48528 }
48529 arg1 = reinterpret_cast< wxSizer * >(argp1);
48530 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48531 if (!SWIG_IsOK(res2)) {
48532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48533 }
48534 arg2 = reinterpret_cast< wxWindow * >(argp2);
48535 {
48536 PyThreadState* __tstate = wxPyBeginAllowThreads();
48537 result = (arg1)->Fit(arg2);
48538 wxPyEndAllowThreads(__tstate);
48539 if (PyErr_Occurred()) SWIG_fail;
48540 }
48541 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48542 return resultobj;
48543 fail:
48544 return NULL;
48545 }
48546
48547
48548 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48549 PyObject *resultobj = 0;
48550 wxSizer *arg1 = (wxSizer *) 0 ;
48551 wxWindow *arg2 = (wxWindow *) 0 ;
48552 void *argp1 = 0 ;
48553 int res1 = 0 ;
48554 void *argp2 = 0 ;
48555 int res2 = 0 ;
48556 PyObject * obj0 = 0 ;
48557 PyObject * obj1 = 0 ;
48558 char * kwnames[] = {
48559 (char *) "self",(char *) "window", NULL
48560 };
48561
48562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48564 if (!SWIG_IsOK(res1)) {
48565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48566 }
48567 arg1 = reinterpret_cast< wxSizer * >(argp1);
48568 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48569 if (!SWIG_IsOK(res2)) {
48570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48571 }
48572 arg2 = reinterpret_cast< wxWindow * >(argp2);
48573 {
48574 PyThreadState* __tstate = wxPyBeginAllowThreads();
48575 (arg1)->FitInside(arg2);
48576 wxPyEndAllowThreads(__tstate);
48577 if (PyErr_Occurred()) SWIG_fail;
48578 }
48579 resultobj = SWIG_Py_Void();
48580 return resultobj;
48581 fail:
48582 return NULL;
48583 }
48584
48585
48586 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48587 PyObject *resultobj = 0;
48588 wxSizer *arg1 = (wxSizer *) 0 ;
48589 wxWindow *arg2 = (wxWindow *) 0 ;
48590 void *argp1 = 0 ;
48591 int res1 = 0 ;
48592 void *argp2 = 0 ;
48593 int res2 = 0 ;
48594 PyObject * obj0 = 0 ;
48595 PyObject * obj1 = 0 ;
48596 char * kwnames[] = {
48597 (char *) "self",(char *) "window", NULL
48598 };
48599
48600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48602 if (!SWIG_IsOK(res1)) {
48603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48604 }
48605 arg1 = reinterpret_cast< wxSizer * >(argp1);
48606 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48607 if (!SWIG_IsOK(res2)) {
48608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48609 }
48610 arg2 = reinterpret_cast< wxWindow * >(argp2);
48611 {
48612 PyThreadState* __tstate = wxPyBeginAllowThreads();
48613 (arg1)->SetSizeHints(arg2);
48614 wxPyEndAllowThreads(__tstate);
48615 if (PyErr_Occurred()) SWIG_fail;
48616 }
48617 resultobj = SWIG_Py_Void();
48618 return resultobj;
48619 fail:
48620 return NULL;
48621 }
48622
48623
48624 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48625 PyObject *resultobj = 0;
48626 wxSizer *arg1 = (wxSizer *) 0 ;
48627 wxWindow *arg2 = (wxWindow *) 0 ;
48628 void *argp1 = 0 ;
48629 int res1 = 0 ;
48630 void *argp2 = 0 ;
48631 int res2 = 0 ;
48632 PyObject * obj0 = 0 ;
48633 PyObject * obj1 = 0 ;
48634 char * kwnames[] = {
48635 (char *) "self",(char *) "window", NULL
48636 };
48637
48638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48640 if (!SWIG_IsOK(res1)) {
48641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48642 }
48643 arg1 = reinterpret_cast< wxSizer * >(argp1);
48644 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48645 if (!SWIG_IsOK(res2)) {
48646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48647 }
48648 arg2 = reinterpret_cast< wxWindow * >(argp2);
48649 {
48650 PyThreadState* __tstate = wxPyBeginAllowThreads();
48651 (arg1)->SetVirtualSizeHints(arg2);
48652 wxPyEndAllowThreads(__tstate);
48653 if (PyErr_Occurred()) SWIG_fail;
48654 }
48655 resultobj = SWIG_Py_Void();
48656 return resultobj;
48657 fail:
48658 return NULL;
48659 }
48660
48661
48662 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48663 PyObject *resultobj = 0;
48664 wxSizer *arg1 = (wxSizer *) 0 ;
48665 bool arg2 = (bool) false ;
48666 void *argp1 = 0 ;
48667 int res1 = 0 ;
48668 bool val2 ;
48669 int ecode2 = 0 ;
48670 PyObject * obj0 = 0 ;
48671 PyObject * obj1 = 0 ;
48672 char * kwnames[] = {
48673 (char *) "self",(char *) "deleteWindows", NULL
48674 };
48675
48676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48678 if (!SWIG_IsOK(res1)) {
48679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48680 }
48681 arg1 = reinterpret_cast< wxSizer * >(argp1);
48682 if (obj1) {
48683 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48684 if (!SWIG_IsOK(ecode2)) {
48685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48686 }
48687 arg2 = static_cast< bool >(val2);
48688 }
48689 {
48690 PyThreadState* __tstate = wxPyBeginAllowThreads();
48691 (arg1)->Clear(arg2);
48692 wxPyEndAllowThreads(__tstate);
48693 if (PyErr_Occurred()) SWIG_fail;
48694 }
48695 resultobj = SWIG_Py_Void();
48696 return resultobj;
48697 fail:
48698 return NULL;
48699 }
48700
48701
48702 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48703 PyObject *resultobj = 0;
48704 wxSizer *arg1 = (wxSizer *) 0 ;
48705 void *argp1 = 0 ;
48706 int res1 = 0 ;
48707 PyObject *swig_obj[1] ;
48708
48709 if (!args) SWIG_fail;
48710 swig_obj[0] = args;
48711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48712 if (!SWIG_IsOK(res1)) {
48713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48714 }
48715 arg1 = reinterpret_cast< wxSizer * >(argp1);
48716 {
48717 PyThreadState* __tstate = wxPyBeginAllowThreads();
48718 (arg1)->DeleteWindows();
48719 wxPyEndAllowThreads(__tstate);
48720 if (PyErr_Occurred()) SWIG_fail;
48721 }
48722 resultobj = SWIG_Py_Void();
48723 return resultobj;
48724 fail:
48725 return NULL;
48726 }
48727
48728
48729 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48730 PyObject *resultobj = 0;
48731 wxSizer *arg1 = (wxSizer *) 0 ;
48732 PyObject *result = 0 ;
48733 void *argp1 = 0 ;
48734 int res1 = 0 ;
48735 PyObject *swig_obj[1] ;
48736
48737 if (!args) SWIG_fail;
48738 swig_obj[0] = args;
48739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48740 if (!SWIG_IsOK(res1)) {
48741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48742 }
48743 arg1 = reinterpret_cast< wxSizer * >(argp1);
48744 {
48745 PyThreadState* __tstate = wxPyBeginAllowThreads();
48746 result = (PyObject *)wxSizer_GetChildren(arg1);
48747 wxPyEndAllowThreads(__tstate);
48748 if (PyErr_Occurred()) SWIG_fail;
48749 }
48750 resultobj = result;
48751 return resultobj;
48752 fail:
48753 return NULL;
48754 }
48755
48756
48757 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48758 PyObject *resultobj = 0;
48759 wxSizer *arg1 = (wxSizer *) 0 ;
48760 PyObject *arg2 = (PyObject *) 0 ;
48761 bool arg3 = (bool) true ;
48762 bool arg4 = (bool) false ;
48763 bool result;
48764 void *argp1 = 0 ;
48765 int res1 = 0 ;
48766 bool val3 ;
48767 int ecode3 = 0 ;
48768 bool val4 ;
48769 int ecode4 = 0 ;
48770 PyObject * obj0 = 0 ;
48771 PyObject * obj1 = 0 ;
48772 PyObject * obj2 = 0 ;
48773 PyObject * obj3 = 0 ;
48774 char * kwnames[] = {
48775 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48776 };
48777
48778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48780 if (!SWIG_IsOK(res1)) {
48781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48782 }
48783 arg1 = reinterpret_cast< wxSizer * >(argp1);
48784 arg2 = obj1;
48785 if (obj2) {
48786 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48787 if (!SWIG_IsOK(ecode3)) {
48788 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48789 }
48790 arg3 = static_cast< bool >(val3);
48791 }
48792 if (obj3) {
48793 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48794 if (!SWIG_IsOK(ecode4)) {
48795 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48796 }
48797 arg4 = static_cast< bool >(val4);
48798 }
48799 {
48800 PyThreadState* __tstate = wxPyBeginAllowThreads();
48801 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48802 wxPyEndAllowThreads(__tstate);
48803 if (PyErr_Occurred()) SWIG_fail;
48804 }
48805 {
48806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48807 }
48808 return resultobj;
48809 fail:
48810 return NULL;
48811 }
48812
48813
48814 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48815 PyObject *resultobj = 0;
48816 wxSizer *arg1 = (wxSizer *) 0 ;
48817 PyObject *arg2 = (PyObject *) 0 ;
48818 bool result;
48819 void *argp1 = 0 ;
48820 int res1 = 0 ;
48821 PyObject * obj0 = 0 ;
48822 PyObject * obj1 = 0 ;
48823 char * kwnames[] = {
48824 (char *) "self",(char *) "item", NULL
48825 };
48826
48827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",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_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48831 }
48832 arg1 = reinterpret_cast< wxSizer * >(argp1);
48833 arg2 = obj1;
48834 {
48835 PyThreadState* __tstate = wxPyBeginAllowThreads();
48836 result = (bool)wxSizer_IsShown(arg1,arg2);
48837 wxPyEndAllowThreads(__tstate);
48838 if (PyErr_Occurred()) SWIG_fail;
48839 }
48840 {
48841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48842 }
48843 return resultobj;
48844 fail:
48845 return NULL;
48846 }
48847
48848
48849 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48850 PyObject *resultobj = 0;
48851 wxSizer *arg1 = (wxSizer *) 0 ;
48852 bool arg2 ;
48853 void *argp1 = 0 ;
48854 int res1 = 0 ;
48855 bool val2 ;
48856 int ecode2 = 0 ;
48857 PyObject * obj0 = 0 ;
48858 PyObject * obj1 = 0 ;
48859 char * kwnames[] = {
48860 (char *) "self",(char *) "show", NULL
48861 };
48862
48863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48865 if (!SWIG_IsOK(res1)) {
48866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48867 }
48868 arg1 = reinterpret_cast< wxSizer * >(argp1);
48869 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48870 if (!SWIG_IsOK(ecode2)) {
48871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48872 }
48873 arg2 = static_cast< bool >(val2);
48874 {
48875 PyThreadState* __tstate = wxPyBeginAllowThreads();
48876 (arg1)->ShowItems(arg2);
48877 wxPyEndAllowThreads(__tstate);
48878 if (PyErr_Occurred()) SWIG_fail;
48879 }
48880 resultobj = SWIG_Py_Void();
48881 return resultobj;
48882 fail:
48883 return NULL;
48884 }
48885
48886
48887 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48888 PyObject *obj;
48889 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48890 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
48891 return SWIG_Py_Void();
48892 }
48893
48894 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48895 PyObject *resultobj = 0;
48896 wxPySizer *result = 0 ;
48897
48898 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
48899 {
48900 PyThreadState* __tstate = wxPyBeginAllowThreads();
48901 result = (wxPySizer *)new wxPySizer();
48902 wxPyEndAllowThreads(__tstate);
48903 if (PyErr_Occurred()) SWIG_fail;
48904 }
48905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
48906 return resultobj;
48907 fail:
48908 return NULL;
48909 }
48910
48911
48912 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48913 PyObject *resultobj = 0;
48914 wxPySizer *arg1 = (wxPySizer *) 0 ;
48915 PyObject *arg2 = (PyObject *) 0 ;
48916 PyObject *arg3 = (PyObject *) 0 ;
48917 void *argp1 = 0 ;
48918 int res1 = 0 ;
48919 PyObject * obj0 = 0 ;
48920 PyObject * obj1 = 0 ;
48921 PyObject * obj2 = 0 ;
48922 char * kwnames[] = {
48923 (char *) "self",(char *) "self",(char *) "_class", NULL
48924 };
48925
48926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
48928 if (!SWIG_IsOK(res1)) {
48929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
48930 }
48931 arg1 = reinterpret_cast< wxPySizer * >(argp1);
48932 arg2 = obj1;
48933 arg3 = obj2;
48934 {
48935 PyThreadState* __tstate = wxPyBeginAllowThreads();
48936 (arg1)->_setCallbackInfo(arg2,arg3);
48937 wxPyEndAllowThreads(__tstate);
48938 if (PyErr_Occurred()) SWIG_fail;
48939 }
48940 resultobj = SWIG_Py_Void();
48941 return resultobj;
48942 fail:
48943 return NULL;
48944 }
48945
48946
48947 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48948 PyObject *obj;
48949 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48950 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
48951 return SWIG_Py_Void();
48952 }
48953
48954 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48955 return SWIG_Python_InitShadowInstance(args);
48956 }
48957
48958 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48959 PyObject *resultobj = 0;
48960 int arg1 = (int) wxHORIZONTAL ;
48961 wxBoxSizer *result = 0 ;
48962 int val1 ;
48963 int ecode1 = 0 ;
48964 PyObject * obj0 = 0 ;
48965 char * kwnames[] = {
48966 (char *) "orient", NULL
48967 };
48968
48969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
48970 if (obj0) {
48971 ecode1 = SWIG_AsVal_int(obj0, &val1);
48972 if (!SWIG_IsOK(ecode1)) {
48973 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
48974 }
48975 arg1 = static_cast< int >(val1);
48976 }
48977 {
48978 PyThreadState* __tstate = wxPyBeginAllowThreads();
48979 result = (wxBoxSizer *)new wxBoxSizer(arg1);
48980 wxPyEndAllowThreads(__tstate);
48981 if (PyErr_Occurred()) SWIG_fail;
48982 }
48983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
48984 return resultobj;
48985 fail:
48986 return NULL;
48987 }
48988
48989
48990 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48991 PyObject *resultobj = 0;
48992 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48993 int result;
48994 void *argp1 = 0 ;
48995 int res1 = 0 ;
48996 PyObject *swig_obj[1] ;
48997
48998 if (!args) SWIG_fail;
48999 swig_obj[0] = args;
49000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49001 if (!SWIG_IsOK(res1)) {
49002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49003 }
49004 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49005 {
49006 PyThreadState* __tstate = wxPyBeginAllowThreads();
49007 result = (int)(arg1)->GetOrientation();
49008 wxPyEndAllowThreads(__tstate);
49009 if (PyErr_Occurred()) SWIG_fail;
49010 }
49011 resultobj = SWIG_From_int(static_cast< int >(result));
49012 return resultobj;
49013 fail:
49014 return NULL;
49015 }
49016
49017
49018 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49019 PyObject *resultobj = 0;
49020 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49021 int arg2 ;
49022 void *argp1 = 0 ;
49023 int res1 = 0 ;
49024 int val2 ;
49025 int ecode2 = 0 ;
49026 PyObject * obj0 = 0 ;
49027 PyObject * obj1 = 0 ;
49028 char * kwnames[] = {
49029 (char *) "self",(char *) "orient", NULL
49030 };
49031
49032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
49033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49034 if (!SWIG_IsOK(res1)) {
49035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49036 }
49037 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49038 ecode2 = SWIG_AsVal_int(obj1, &val2);
49039 if (!SWIG_IsOK(ecode2)) {
49040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
49041 }
49042 arg2 = static_cast< int >(val2);
49043 {
49044 PyThreadState* __tstate = wxPyBeginAllowThreads();
49045 (arg1)->SetOrientation(arg2);
49046 wxPyEndAllowThreads(__tstate);
49047 if (PyErr_Occurred()) SWIG_fail;
49048 }
49049 resultobj = SWIG_Py_Void();
49050 return resultobj;
49051 fail:
49052 return NULL;
49053 }
49054
49055
49056 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49057 PyObject *obj;
49058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49059 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
49060 return SWIG_Py_Void();
49061 }
49062
49063 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49064 return SWIG_Python_InitShadowInstance(args);
49065 }
49066
49067 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49068 PyObject *resultobj = 0;
49069 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
49070 int arg2 = (int) wxHORIZONTAL ;
49071 wxStaticBoxSizer *result = 0 ;
49072 void *argp1 = 0 ;
49073 int res1 = 0 ;
49074 int val2 ;
49075 int ecode2 = 0 ;
49076 PyObject * obj0 = 0 ;
49077 PyObject * obj1 = 0 ;
49078 char * kwnames[] = {
49079 (char *) "box",(char *) "orient", NULL
49080 };
49081
49082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
49084 if (!SWIG_IsOK(res1)) {
49085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
49086 }
49087 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
49088 if (obj1) {
49089 ecode2 = SWIG_AsVal_int(obj1, &val2);
49090 if (!SWIG_IsOK(ecode2)) {
49091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
49092 }
49093 arg2 = static_cast< int >(val2);
49094 }
49095 {
49096 PyThreadState* __tstate = wxPyBeginAllowThreads();
49097 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
49098 wxPyEndAllowThreads(__tstate);
49099 if (PyErr_Occurred()) SWIG_fail;
49100 }
49101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
49102 return resultobj;
49103 fail:
49104 return NULL;
49105 }
49106
49107
49108 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49109 PyObject *resultobj = 0;
49110 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
49111 wxStaticBox *result = 0 ;
49112 void *argp1 = 0 ;
49113 int res1 = 0 ;
49114 PyObject *swig_obj[1] ;
49115
49116 if (!args) SWIG_fail;
49117 swig_obj[0] = args;
49118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
49119 if (!SWIG_IsOK(res1)) {
49120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
49121 }
49122 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
49123 {
49124 PyThreadState* __tstate = wxPyBeginAllowThreads();
49125 result = (wxStaticBox *)(arg1)->GetStaticBox();
49126 wxPyEndAllowThreads(__tstate);
49127 if (PyErr_Occurred()) SWIG_fail;
49128 }
49129 {
49130 resultobj = wxPyMake_wxObject(result, (bool)0);
49131 }
49132 return resultobj;
49133 fail:
49134 return NULL;
49135 }
49136
49137
49138 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49139 PyObject *obj;
49140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49141 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
49142 return SWIG_Py_Void();
49143 }
49144
49145 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49146 return SWIG_Python_InitShadowInstance(args);
49147 }
49148
49149 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49150 PyObject *resultobj = 0;
49151 int arg1 = (int) 1 ;
49152 int arg2 = (int) 0 ;
49153 int arg3 = (int) 0 ;
49154 int arg4 = (int) 0 ;
49155 wxGridSizer *result = 0 ;
49156 int val1 ;
49157 int ecode1 = 0 ;
49158 int val2 ;
49159 int ecode2 = 0 ;
49160 int val3 ;
49161 int ecode3 = 0 ;
49162 int val4 ;
49163 int ecode4 = 0 ;
49164 PyObject * obj0 = 0 ;
49165 PyObject * obj1 = 0 ;
49166 PyObject * obj2 = 0 ;
49167 PyObject * obj3 = 0 ;
49168 char * kwnames[] = {
49169 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49170 };
49171
49172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49173 if (obj0) {
49174 ecode1 = SWIG_AsVal_int(obj0, &val1);
49175 if (!SWIG_IsOK(ecode1)) {
49176 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
49177 }
49178 arg1 = static_cast< int >(val1);
49179 }
49180 if (obj1) {
49181 ecode2 = SWIG_AsVal_int(obj1, &val2);
49182 if (!SWIG_IsOK(ecode2)) {
49183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
49184 }
49185 arg2 = static_cast< int >(val2);
49186 }
49187 if (obj2) {
49188 ecode3 = SWIG_AsVal_int(obj2, &val3);
49189 if (!SWIG_IsOK(ecode3)) {
49190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
49191 }
49192 arg3 = static_cast< int >(val3);
49193 }
49194 if (obj3) {
49195 ecode4 = SWIG_AsVal_int(obj3, &val4);
49196 if (!SWIG_IsOK(ecode4)) {
49197 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
49198 }
49199 arg4 = static_cast< int >(val4);
49200 }
49201 {
49202 PyThreadState* __tstate = wxPyBeginAllowThreads();
49203 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
49204 wxPyEndAllowThreads(__tstate);
49205 if (PyErr_Occurred()) SWIG_fail;
49206 }
49207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
49208 return resultobj;
49209 fail:
49210 return NULL;
49211 }
49212
49213
49214 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49215 PyObject *resultobj = 0;
49216 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49217 int arg2 ;
49218 void *argp1 = 0 ;
49219 int res1 = 0 ;
49220 int val2 ;
49221 int ecode2 = 0 ;
49222 PyObject * obj0 = 0 ;
49223 PyObject * obj1 = 0 ;
49224 char * kwnames[] = {
49225 (char *) "self",(char *) "cols", NULL
49226 };
49227
49228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
49229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49230 if (!SWIG_IsOK(res1)) {
49231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49232 }
49233 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49234 ecode2 = SWIG_AsVal_int(obj1, &val2);
49235 if (!SWIG_IsOK(ecode2)) {
49236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
49237 }
49238 arg2 = static_cast< int >(val2);
49239 {
49240 PyThreadState* __tstate = wxPyBeginAllowThreads();
49241 (arg1)->SetCols(arg2);
49242 wxPyEndAllowThreads(__tstate);
49243 if (PyErr_Occurred()) SWIG_fail;
49244 }
49245 resultobj = SWIG_Py_Void();
49246 return resultobj;
49247 fail:
49248 return NULL;
49249 }
49250
49251
49252 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49253 PyObject *resultobj = 0;
49254 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49255 int arg2 ;
49256 void *argp1 = 0 ;
49257 int res1 = 0 ;
49258 int val2 ;
49259 int ecode2 = 0 ;
49260 PyObject * obj0 = 0 ;
49261 PyObject * obj1 = 0 ;
49262 char * kwnames[] = {
49263 (char *) "self",(char *) "rows", NULL
49264 };
49265
49266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
49267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49268 if (!SWIG_IsOK(res1)) {
49269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49270 }
49271 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49272 ecode2 = SWIG_AsVal_int(obj1, &val2);
49273 if (!SWIG_IsOK(ecode2)) {
49274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
49275 }
49276 arg2 = static_cast< int >(val2);
49277 {
49278 PyThreadState* __tstate = wxPyBeginAllowThreads();
49279 (arg1)->SetRows(arg2);
49280 wxPyEndAllowThreads(__tstate);
49281 if (PyErr_Occurred()) SWIG_fail;
49282 }
49283 resultobj = SWIG_Py_Void();
49284 return resultobj;
49285 fail:
49286 return NULL;
49287 }
49288
49289
49290 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49291 PyObject *resultobj = 0;
49292 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49293 int arg2 ;
49294 void *argp1 = 0 ;
49295 int res1 = 0 ;
49296 int val2 ;
49297 int ecode2 = 0 ;
49298 PyObject * obj0 = 0 ;
49299 PyObject * obj1 = 0 ;
49300 char * kwnames[] = {
49301 (char *) "self",(char *) "gap", NULL
49302 };
49303
49304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
49305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49306 if (!SWIG_IsOK(res1)) {
49307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49308 }
49309 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49310 ecode2 = SWIG_AsVal_int(obj1, &val2);
49311 if (!SWIG_IsOK(ecode2)) {
49312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
49313 }
49314 arg2 = static_cast< int >(val2);
49315 {
49316 PyThreadState* __tstate = wxPyBeginAllowThreads();
49317 (arg1)->SetVGap(arg2);
49318 wxPyEndAllowThreads(__tstate);
49319 if (PyErr_Occurred()) SWIG_fail;
49320 }
49321 resultobj = SWIG_Py_Void();
49322 return resultobj;
49323 fail:
49324 return NULL;
49325 }
49326
49327
49328 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49329 PyObject *resultobj = 0;
49330 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49331 int arg2 ;
49332 void *argp1 = 0 ;
49333 int res1 = 0 ;
49334 int val2 ;
49335 int ecode2 = 0 ;
49336 PyObject * obj0 = 0 ;
49337 PyObject * obj1 = 0 ;
49338 char * kwnames[] = {
49339 (char *) "self",(char *) "gap", NULL
49340 };
49341
49342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
49343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49344 if (!SWIG_IsOK(res1)) {
49345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49346 }
49347 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49348 ecode2 = SWIG_AsVal_int(obj1, &val2);
49349 if (!SWIG_IsOK(ecode2)) {
49350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
49351 }
49352 arg2 = static_cast< int >(val2);
49353 {
49354 PyThreadState* __tstate = wxPyBeginAllowThreads();
49355 (arg1)->SetHGap(arg2);
49356 wxPyEndAllowThreads(__tstate);
49357 if (PyErr_Occurred()) SWIG_fail;
49358 }
49359 resultobj = SWIG_Py_Void();
49360 return resultobj;
49361 fail:
49362 return NULL;
49363 }
49364
49365
49366 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49367 PyObject *resultobj = 0;
49368 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49369 int result;
49370 void *argp1 = 0 ;
49371 int res1 = 0 ;
49372 PyObject *swig_obj[1] ;
49373
49374 if (!args) SWIG_fail;
49375 swig_obj[0] = args;
49376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49377 if (!SWIG_IsOK(res1)) {
49378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49379 }
49380 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49381 {
49382 PyThreadState* __tstate = wxPyBeginAllowThreads();
49383 result = (int)(arg1)->GetCols();
49384 wxPyEndAllowThreads(__tstate);
49385 if (PyErr_Occurred()) SWIG_fail;
49386 }
49387 resultobj = SWIG_From_int(static_cast< int >(result));
49388 return resultobj;
49389 fail:
49390 return NULL;
49391 }
49392
49393
49394 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49395 PyObject *resultobj = 0;
49396 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49397 int result;
49398 void *argp1 = 0 ;
49399 int res1 = 0 ;
49400 PyObject *swig_obj[1] ;
49401
49402 if (!args) SWIG_fail;
49403 swig_obj[0] = args;
49404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49405 if (!SWIG_IsOK(res1)) {
49406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49407 }
49408 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49409 {
49410 PyThreadState* __tstate = wxPyBeginAllowThreads();
49411 result = (int)(arg1)->GetRows();
49412 wxPyEndAllowThreads(__tstate);
49413 if (PyErr_Occurred()) SWIG_fail;
49414 }
49415 resultobj = SWIG_From_int(static_cast< int >(result));
49416 return resultobj;
49417 fail:
49418 return NULL;
49419 }
49420
49421
49422 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49423 PyObject *resultobj = 0;
49424 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49425 int result;
49426 void *argp1 = 0 ;
49427 int res1 = 0 ;
49428 PyObject *swig_obj[1] ;
49429
49430 if (!args) SWIG_fail;
49431 swig_obj[0] = args;
49432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49433 if (!SWIG_IsOK(res1)) {
49434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49435 }
49436 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49437 {
49438 PyThreadState* __tstate = wxPyBeginAllowThreads();
49439 result = (int)(arg1)->GetVGap();
49440 wxPyEndAllowThreads(__tstate);
49441 if (PyErr_Occurred()) SWIG_fail;
49442 }
49443 resultobj = SWIG_From_int(static_cast< int >(result));
49444 return resultobj;
49445 fail:
49446 return NULL;
49447 }
49448
49449
49450 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49451 PyObject *resultobj = 0;
49452 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49453 int result;
49454 void *argp1 = 0 ;
49455 int res1 = 0 ;
49456 PyObject *swig_obj[1] ;
49457
49458 if (!args) SWIG_fail;
49459 swig_obj[0] = args;
49460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49461 if (!SWIG_IsOK(res1)) {
49462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49463 }
49464 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49465 {
49466 PyThreadState* __tstate = wxPyBeginAllowThreads();
49467 result = (int)(arg1)->GetHGap();
49468 wxPyEndAllowThreads(__tstate);
49469 if (PyErr_Occurred()) SWIG_fail;
49470 }
49471 resultobj = SWIG_From_int(static_cast< int >(result));
49472 return resultobj;
49473 fail:
49474 return NULL;
49475 }
49476
49477
49478 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49479 PyObject *obj;
49480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49481 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49482 return SWIG_Py_Void();
49483 }
49484
49485 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49486 return SWIG_Python_InitShadowInstance(args);
49487 }
49488
49489 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49490 PyObject *resultobj = 0;
49491 int arg1 = (int) 1 ;
49492 int arg2 = (int) 0 ;
49493 int arg3 = (int) 0 ;
49494 int arg4 = (int) 0 ;
49495 wxFlexGridSizer *result = 0 ;
49496 int val1 ;
49497 int ecode1 = 0 ;
49498 int val2 ;
49499 int ecode2 = 0 ;
49500 int val3 ;
49501 int ecode3 = 0 ;
49502 int val4 ;
49503 int ecode4 = 0 ;
49504 PyObject * obj0 = 0 ;
49505 PyObject * obj1 = 0 ;
49506 PyObject * obj2 = 0 ;
49507 PyObject * obj3 = 0 ;
49508 char * kwnames[] = {
49509 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49510 };
49511
49512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49513 if (obj0) {
49514 ecode1 = SWIG_AsVal_int(obj0, &val1);
49515 if (!SWIG_IsOK(ecode1)) {
49516 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49517 }
49518 arg1 = static_cast< int >(val1);
49519 }
49520 if (obj1) {
49521 ecode2 = SWIG_AsVal_int(obj1, &val2);
49522 if (!SWIG_IsOK(ecode2)) {
49523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49524 }
49525 arg2 = static_cast< int >(val2);
49526 }
49527 if (obj2) {
49528 ecode3 = SWIG_AsVal_int(obj2, &val3);
49529 if (!SWIG_IsOK(ecode3)) {
49530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49531 }
49532 arg3 = static_cast< int >(val3);
49533 }
49534 if (obj3) {
49535 ecode4 = SWIG_AsVal_int(obj3, &val4);
49536 if (!SWIG_IsOK(ecode4)) {
49537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49538 }
49539 arg4 = static_cast< int >(val4);
49540 }
49541 {
49542 PyThreadState* __tstate = wxPyBeginAllowThreads();
49543 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49544 wxPyEndAllowThreads(__tstate);
49545 if (PyErr_Occurred()) SWIG_fail;
49546 }
49547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49548 return resultobj;
49549 fail:
49550 return NULL;
49551 }
49552
49553
49554 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49555 PyObject *resultobj = 0;
49556 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49557 size_t arg2 ;
49558 int arg3 = (int) 0 ;
49559 void *argp1 = 0 ;
49560 int res1 = 0 ;
49561 size_t val2 ;
49562 int ecode2 = 0 ;
49563 int val3 ;
49564 int ecode3 = 0 ;
49565 PyObject * obj0 = 0 ;
49566 PyObject * obj1 = 0 ;
49567 PyObject * obj2 = 0 ;
49568 char * kwnames[] = {
49569 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49570 };
49571
49572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49574 if (!SWIG_IsOK(res1)) {
49575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49576 }
49577 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49578 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49579 if (!SWIG_IsOK(ecode2)) {
49580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49581 }
49582 arg2 = static_cast< size_t >(val2);
49583 if (obj2) {
49584 ecode3 = SWIG_AsVal_int(obj2, &val3);
49585 if (!SWIG_IsOK(ecode3)) {
49586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49587 }
49588 arg3 = static_cast< int >(val3);
49589 }
49590 {
49591 PyThreadState* __tstate = wxPyBeginAllowThreads();
49592 (arg1)->AddGrowableRow(arg2,arg3);
49593 wxPyEndAllowThreads(__tstate);
49594 if (PyErr_Occurred()) SWIG_fail;
49595 }
49596 resultobj = SWIG_Py_Void();
49597 return resultobj;
49598 fail:
49599 return NULL;
49600 }
49601
49602
49603 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49604 PyObject *resultobj = 0;
49605 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49606 size_t arg2 ;
49607 void *argp1 = 0 ;
49608 int res1 = 0 ;
49609 size_t val2 ;
49610 int ecode2 = 0 ;
49611 PyObject * obj0 = 0 ;
49612 PyObject * obj1 = 0 ;
49613 char * kwnames[] = {
49614 (char *) "self",(char *) "idx", NULL
49615 };
49616
49617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49619 if (!SWIG_IsOK(res1)) {
49620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49621 }
49622 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49623 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49624 if (!SWIG_IsOK(ecode2)) {
49625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49626 }
49627 arg2 = static_cast< size_t >(val2);
49628 {
49629 PyThreadState* __tstate = wxPyBeginAllowThreads();
49630 (arg1)->RemoveGrowableRow(arg2);
49631 wxPyEndAllowThreads(__tstate);
49632 if (PyErr_Occurred()) SWIG_fail;
49633 }
49634 resultobj = SWIG_Py_Void();
49635 return resultobj;
49636 fail:
49637 return NULL;
49638 }
49639
49640
49641 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49642 PyObject *resultobj = 0;
49643 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49644 size_t arg2 ;
49645 int arg3 = (int) 0 ;
49646 void *argp1 = 0 ;
49647 int res1 = 0 ;
49648 size_t val2 ;
49649 int ecode2 = 0 ;
49650 int val3 ;
49651 int ecode3 = 0 ;
49652 PyObject * obj0 = 0 ;
49653 PyObject * obj1 = 0 ;
49654 PyObject * obj2 = 0 ;
49655 char * kwnames[] = {
49656 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49657 };
49658
49659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49661 if (!SWIG_IsOK(res1)) {
49662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49663 }
49664 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49665 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49666 if (!SWIG_IsOK(ecode2)) {
49667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49668 }
49669 arg2 = static_cast< size_t >(val2);
49670 if (obj2) {
49671 ecode3 = SWIG_AsVal_int(obj2, &val3);
49672 if (!SWIG_IsOK(ecode3)) {
49673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49674 }
49675 arg3 = static_cast< int >(val3);
49676 }
49677 {
49678 PyThreadState* __tstate = wxPyBeginAllowThreads();
49679 (arg1)->AddGrowableCol(arg2,arg3);
49680 wxPyEndAllowThreads(__tstate);
49681 if (PyErr_Occurred()) SWIG_fail;
49682 }
49683 resultobj = SWIG_Py_Void();
49684 return resultobj;
49685 fail:
49686 return NULL;
49687 }
49688
49689
49690 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49691 PyObject *resultobj = 0;
49692 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49693 size_t arg2 ;
49694 void *argp1 = 0 ;
49695 int res1 = 0 ;
49696 size_t val2 ;
49697 int ecode2 = 0 ;
49698 PyObject * obj0 = 0 ;
49699 PyObject * obj1 = 0 ;
49700 char * kwnames[] = {
49701 (char *) "self",(char *) "idx", NULL
49702 };
49703
49704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49706 if (!SWIG_IsOK(res1)) {
49707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49708 }
49709 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49710 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49711 if (!SWIG_IsOK(ecode2)) {
49712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49713 }
49714 arg2 = static_cast< size_t >(val2);
49715 {
49716 PyThreadState* __tstate = wxPyBeginAllowThreads();
49717 (arg1)->RemoveGrowableCol(arg2);
49718 wxPyEndAllowThreads(__tstate);
49719 if (PyErr_Occurred()) SWIG_fail;
49720 }
49721 resultobj = SWIG_Py_Void();
49722 return resultobj;
49723 fail:
49724 return NULL;
49725 }
49726
49727
49728 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49729 PyObject *resultobj = 0;
49730 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49731 int arg2 ;
49732 void *argp1 = 0 ;
49733 int res1 = 0 ;
49734 int val2 ;
49735 int ecode2 = 0 ;
49736 PyObject * obj0 = 0 ;
49737 PyObject * obj1 = 0 ;
49738 char * kwnames[] = {
49739 (char *) "self",(char *) "direction", NULL
49740 };
49741
49742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49744 if (!SWIG_IsOK(res1)) {
49745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49746 }
49747 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49748 ecode2 = SWIG_AsVal_int(obj1, &val2);
49749 if (!SWIG_IsOK(ecode2)) {
49750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49751 }
49752 arg2 = static_cast< int >(val2);
49753 {
49754 PyThreadState* __tstate = wxPyBeginAllowThreads();
49755 (arg1)->SetFlexibleDirection(arg2);
49756 wxPyEndAllowThreads(__tstate);
49757 if (PyErr_Occurred()) SWIG_fail;
49758 }
49759 resultobj = SWIG_Py_Void();
49760 return resultobj;
49761 fail:
49762 return NULL;
49763 }
49764
49765
49766 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49767 PyObject *resultobj = 0;
49768 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49769 int result;
49770 void *argp1 = 0 ;
49771 int res1 = 0 ;
49772 PyObject *swig_obj[1] ;
49773
49774 if (!args) SWIG_fail;
49775 swig_obj[0] = args;
49776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49777 if (!SWIG_IsOK(res1)) {
49778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49779 }
49780 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49781 {
49782 PyThreadState* __tstate = wxPyBeginAllowThreads();
49783 result = (int)(arg1)->GetFlexibleDirection();
49784 wxPyEndAllowThreads(__tstate);
49785 if (PyErr_Occurred()) SWIG_fail;
49786 }
49787 resultobj = SWIG_From_int(static_cast< int >(result));
49788 return resultobj;
49789 fail:
49790 return NULL;
49791 }
49792
49793
49794 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49795 PyObject *resultobj = 0;
49796 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49797 wxFlexSizerGrowMode arg2 ;
49798 void *argp1 = 0 ;
49799 int res1 = 0 ;
49800 int val2 ;
49801 int ecode2 = 0 ;
49802 PyObject * obj0 = 0 ;
49803 PyObject * obj1 = 0 ;
49804 char * kwnames[] = {
49805 (char *) "self",(char *) "mode", NULL
49806 };
49807
49808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49810 if (!SWIG_IsOK(res1)) {
49811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49812 }
49813 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49814 ecode2 = SWIG_AsVal_int(obj1, &val2);
49815 if (!SWIG_IsOK(ecode2)) {
49816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49817 }
49818 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49819 {
49820 PyThreadState* __tstate = wxPyBeginAllowThreads();
49821 (arg1)->SetNonFlexibleGrowMode(arg2);
49822 wxPyEndAllowThreads(__tstate);
49823 if (PyErr_Occurred()) SWIG_fail;
49824 }
49825 resultobj = SWIG_Py_Void();
49826 return resultobj;
49827 fail:
49828 return NULL;
49829 }
49830
49831
49832 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49833 PyObject *resultobj = 0;
49834 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49835 wxFlexSizerGrowMode result;
49836 void *argp1 = 0 ;
49837 int res1 = 0 ;
49838 PyObject *swig_obj[1] ;
49839
49840 if (!args) SWIG_fail;
49841 swig_obj[0] = args;
49842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49843 if (!SWIG_IsOK(res1)) {
49844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49845 }
49846 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49847 {
49848 PyThreadState* __tstate = wxPyBeginAllowThreads();
49849 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49850 wxPyEndAllowThreads(__tstate);
49851 if (PyErr_Occurred()) SWIG_fail;
49852 }
49853 resultobj = SWIG_From_int(static_cast< int >(result));
49854 return resultobj;
49855 fail:
49856 return NULL;
49857 }
49858
49859
49860 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49861 PyObject *resultobj = 0;
49862 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49863 wxArrayInt *result = 0 ;
49864 void *argp1 = 0 ;
49865 int res1 = 0 ;
49866 PyObject *swig_obj[1] ;
49867
49868 if (!args) SWIG_fail;
49869 swig_obj[0] = args;
49870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49871 if (!SWIG_IsOK(res1)) {
49872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49873 }
49874 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49875 {
49876 PyThreadState* __tstate = wxPyBeginAllowThreads();
49877 {
49878 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
49879 result = (wxArrayInt *) &_result_ref;
49880 }
49881 wxPyEndAllowThreads(__tstate);
49882 if (PyErr_Occurred()) SWIG_fail;
49883 }
49884 {
49885 resultobj = PyList_New(0);
49886 size_t idx;
49887 for (idx = 0; idx < result->GetCount(); idx += 1) {
49888 PyObject* val = PyInt_FromLong( result->Item(idx) );
49889 PyList_Append(resultobj, val);
49890 Py_DECREF(val);
49891 }
49892 }
49893 return resultobj;
49894 fail:
49895 return NULL;
49896 }
49897
49898
49899 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49900 PyObject *resultobj = 0;
49901 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49902 wxArrayInt *result = 0 ;
49903 void *argp1 = 0 ;
49904 int res1 = 0 ;
49905 PyObject *swig_obj[1] ;
49906
49907 if (!args) SWIG_fail;
49908 swig_obj[0] = args;
49909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49910 if (!SWIG_IsOK(res1)) {
49911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49912 }
49913 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49914 {
49915 PyThreadState* __tstate = wxPyBeginAllowThreads();
49916 {
49917 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
49918 result = (wxArrayInt *) &_result_ref;
49919 }
49920 wxPyEndAllowThreads(__tstate);
49921 if (PyErr_Occurred()) SWIG_fail;
49922 }
49923 {
49924 resultobj = PyList_New(0);
49925 size_t idx;
49926 for (idx = 0; idx < result->GetCount(); idx += 1) {
49927 PyObject* val = PyInt_FromLong( result->Item(idx) );
49928 PyList_Append(resultobj, val);
49929 Py_DECREF(val);
49930 }
49931 }
49932 return resultobj;
49933 fail:
49934 return NULL;
49935 }
49936
49937
49938 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49939 PyObject *obj;
49940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49941 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
49942 return SWIG_Py_Void();
49943 }
49944
49945 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49946 return SWIG_Python_InitShadowInstance(args);
49947 }
49948
49949 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49950 PyObject *resultobj = 0;
49951 wxStdDialogButtonSizer *result = 0 ;
49952
49953 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
49954 {
49955 PyThreadState* __tstate = wxPyBeginAllowThreads();
49956 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
49957 wxPyEndAllowThreads(__tstate);
49958 if (PyErr_Occurred()) SWIG_fail;
49959 }
49960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
49961 return resultobj;
49962 fail:
49963 return NULL;
49964 }
49965
49966
49967 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49968 PyObject *resultobj = 0;
49969 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49970 wxButton *arg2 = (wxButton *) 0 ;
49971 void *argp1 = 0 ;
49972 int res1 = 0 ;
49973 void *argp2 = 0 ;
49974 int res2 = 0 ;
49975 PyObject * obj0 = 0 ;
49976 PyObject * obj1 = 0 ;
49977 char * kwnames[] = {
49978 (char *) "self",(char *) "button", NULL
49979 };
49980
49981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
49982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49983 if (!SWIG_IsOK(res1)) {
49984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49985 }
49986 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49987 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49988 if (!SWIG_IsOK(res2)) {
49989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
49990 }
49991 arg2 = reinterpret_cast< wxButton * >(argp2);
49992 {
49993 PyThreadState* __tstate = wxPyBeginAllowThreads();
49994 (arg1)->AddButton(arg2);
49995 wxPyEndAllowThreads(__tstate);
49996 if (PyErr_Occurred()) SWIG_fail;
49997 }
49998 resultobj = SWIG_Py_Void();
49999 return resultobj;
50000 fail:
50001 return NULL;
50002 }
50003
50004
50005 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50006 PyObject *resultobj = 0;
50007 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50008 void *argp1 = 0 ;
50009 int res1 = 0 ;
50010 PyObject *swig_obj[1] ;
50011
50012 if (!args) SWIG_fail;
50013 swig_obj[0] = args;
50014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50015 if (!SWIG_IsOK(res1)) {
50016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50017 }
50018 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50019 {
50020 PyThreadState* __tstate = wxPyBeginAllowThreads();
50021 (arg1)->Realize();
50022 wxPyEndAllowThreads(__tstate);
50023 if (PyErr_Occurred()) SWIG_fail;
50024 }
50025 resultobj = SWIG_Py_Void();
50026 return resultobj;
50027 fail:
50028 return NULL;
50029 }
50030
50031
50032 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50033 PyObject *resultobj = 0;
50034 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50035 wxButton *arg2 = (wxButton *) 0 ;
50036 void *argp1 = 0 ;
50037 int res1 = 0 ;
50038 void *argp2 = 0 ;
50039 int res2 = 0 ;
50040 PyObject * obj0 = 0 ;
50041 PyObject * obj1 = 0 ;
50042 char * kwnames[] = {
50043 (char *) "self",(char *) "button", NULL
50044 };
50045
50046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50048 if (!SWIG_IsOK(res1)) {
50049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50050 }
50051 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50052 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50053 if (!SWIG_IsOK(res2)) {
50054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50055 }
50056 arg2 = reinterpret_cast< wxButton * >(argp2);
50057 {
50058 PyThreadState* __tstate = wxPyBeginAllowThreads();
50059 (arg1)->SetAffirmativeButton(arg2);
50060 wxPyEndAllowThreads(__tstate);
50061 if (PyErr_Occurred()) SWIG_fail;
50062 }
50063 resultobj = SWIG_Py_Void();
50064 return resultobj;
50065 fail:
50066 return NULL;
50067 }
50068
50069
50070 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50071 PyObject *resultobj = 0;
50072 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50073 wxButton *arg2 = (wxButton *) 0 ;
50074 void *argp1 = 0 ;
50075 int res1 = 0 ;
50076 void *argp2 = 0 ;
50077 int res2 = 0 ;
50078 PyObject * obj0 = 0 ;
50079 PyObject * obj1 = 0 ;
50080 char * kwnames[] = {
50081 (char *) "self",(char *) "button", NULL
50082 };
50083
50084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50086 if (!SWIG_IsOK(res1)) {
50087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50088 }
50089 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50090 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50091 if (!SWIG_IsOK(res2)) {
50092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50093 }
50094 arg2 = reinterpret_cast< wxButton * >(argp2);
50095 {
50096 PyThreadState* __tstate = wxPyBeginAllowThreads();
50097 (arg1)->SetNegativeButton(arg2);
50098 wxPyEndAllowThreads(__tstate);
50099 if (PyErr_Occurred()) SWIG_fail;
50100 }
50101 resultobj = SWIG_Py_Void();
50102 return resultobj;
50103 fail:
50104 return NULL;
50105 }
50106
50107
50108 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50109 PyObject *resultobj = 0;
50110 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50111 wxButton *arg2 = (wxButton *) 0 ;
50112 void *argp1 = 0 ;
50113 int res1 = 0 ;
50114 void *argp2 = 0 ;
50115 int res2 = 0 ;
50116 PyObject * obj0 = 0 ;
50117 PyObject * obj1 = 0 ;
50118 char * kwnames[] = {
50119 (char *) "self",(char *) "button", NULL
50120 };
50121
50122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
50123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50124 if (!SWIG_IsOK(res1)) {
50125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50126 }
50127 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50128 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50129 if (!SWIG_IsOK(res2)) {
50130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
50131 }
50132 arg2 = reinterpret_cast< wxButton * >(argp2);
50133 {
50134 PyThreadState* __tstate = wxPyBeginAllowThreads();
50135 (arg1)->SetCancelButton(arg2);
50136 wxPyEndAllowThreads(__tstate);
50137 if (PyErr_Occurred()) SWIG_fail;
50138 }
50139 resultobj = SWIG_Py_Void();
50140 return resultobj;
50141 fail:
50142 return NULL;
50143 }
50144
50145
50146 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50147 PyObject *resultobj = 0;
50148 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50149 wxButton *result = 0 ;
50150 void *argp1 = 0 ;
50151 int res1 = 0 ;
50152 PyObject *swig_obj[1] ;
50153
50154 if (!args) SWIG_fail;
50155 swig_obj[0] = args;
50156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50157 if (!SWIG_IsOK(res1)) {
50158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50159 }
50160 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50161 {
50162 PyThreadState* __tstate = wxPyBeginAllowThreads();
50163 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
50164 wxPyEndAllowThreads(__tstate);
50165 if (PyErr_Occurred()) SWIG_fail;
50166 }
50167 {
50168 resultobj = wxPyMake_wxObject(result, (bool)0);
50169 }
50170 return resultobj;
50171 fail:
50172 return NULL;
50173 }
50174
50175
50176 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50177 PyObject *resultobj = 0;
50178 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50179 wxButton *result = 0 ;
50180 void *argp1 = 0 ;
50181 int res1 = 0 ;
50182 PyObject *swig_obj[1] ;
50183
50184 if (!args) SWIG_fail;
50185 swig_obj[0] = args;
50186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50187 if (!SWIG_IsOK(res1)) {
50188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50189 }
50190 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50191 {
50192 PyThreadState* __tstate = wxPyBeginAllowThreads();
50193 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
50194 wxPyEndAllowThreads(__tstate);
50195 if (PyErr_Occurred()) SWIG_fail;
50196 }
50197 {
50198 resultobj = wxPyMake_wxObject(result, (bool)0);
50199 }
50200 return resultobj;
50201 fail:
50202 return NULL;
50203 }
50204
50205
50206 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50207 PyObject *resultobj = 0;
50208 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50209 wxButton *result = 0 ;
50210 void *argp1 = 0 ;
50211 int res1 = 0 ;
50212 PyObject *swig_obj[1] ;
50213
50214 if (!args) SWIG_fail;
50215 swig_obj[0] = args;
50216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50217 if (!SWIG_IsOK(res1)) {
50218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50219 }
50220 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50221 {
50222 PyThreadState* __tstate = wxPyBeginAllowThreads();
50223 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
50224 wxPyEndAllowThreads(__tstate);
50225 if (PyErr_Occurred()) SWIG_fail;
50226 }
50227 {
50228 resultobj = wxPyMake_wxObject(result, (bool)0);
50229 }
50230 return resultobj;
50231 fail:
50232 return NULL;
50233 }
50234
50235
50236 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50237 PyObject *resultobj = 0;
50238 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50239 wxButton *result = 0 ;
50240 void *argp1 = 0 ;
50241 int res1 = 0 ;
50242 PyObject *swig_obj[1] ;
50243
50244 if (!args) SWIG_fail;
50245 swig_obj[0] = args;
50246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50247 if (!SWIG_IsOK(res1)) {
50248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50249 }
50250 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50251 {
50252 PyThreadState* __tstate = wxPyBeginAllowThreads();
50253 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
50254 wxPyEndAllowThreads(__tstate);
50255 if (PyErr_Occurred()) SWIG_fail;
50256 }
50257 {
50258 resultobj = wxPyMake_wxObject(result, (bool)0);
50259 }
50260 return resultobj;
50261 fail:
50262 return NULL;
50263 }
50264
50265
50266 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50267 PyObject *resultobj = 0;
50268 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50269 wxButton *result = 0 ;
50270 void *argp1 = 0 ;
50271 int res1 = 0 ;
50272 PyObject *swig_obj[1] ;
50273
50274 if (!args) SWIG_fail;
50275 swig_obj[0] = args;
50276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50277 if (!SWIG_IsOK(res1)) {
50278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50279 }
50280 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50281 {
50282 PyThreadState* __tstate = wxPyBeginAllowThreads();
50283 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
50284 wxPyEndAllowThreads(__tstate);
50285 if (PyErr_Occurred()) SWIG_fail;
50286 }
50287 {
50288 resultobj = wxPyMake_wxObject(result, (bool)0);
50289 }
50290 return resultobj;
50291 fail:
50292 return NULL;
50293 }
50294
50295
50296 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50297 PyObject *obj;
50298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50299 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
50300 return SWIG_Py_Void();
50301 }
50302
50303 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50304 return SWIG_Python_InitShadowInstance(args);
50305 }
50306
50307 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50308 PyObject *resultobj = 0;
50309 int arg1 = (int) 0 ;
50310 int arg2 = (int) 0 ;
50311 wxGBPosition *result = 0 ;
50312 int val1 ;
50313 int ecode1 = 0 ;
50314 int val2 ;
50315 int ecode2 = 0 ;
50316 PyObject * obj0 = 0 ;
50317 PyObject * obj1 = 0 ;
50318 char * kwnames[] = {
50319 (char *) "row",(char *) "col", NULL
50320 };
50321
50322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50323 if (obj0) {
50324 ecode1 = SWIG_AsVal_int(obj0, &val1);
50325 if (!SWIG_IsOK(ecode1)) {
50326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
50327 }
50328 arg1 = static_cast< int >(val1);
50329 }
50330 if (obj1) {
50331 ecode2 = SWIG_AsVal_int(obj1, &val2);
50332 if (!SWIG_IsOK(ecode2)) {
50333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
50334 }
50335 arg2 = static_cast< int >(val2);
50336 }
50337 {
50338 PyThreadState* __tstate = wxPyBeginAllowThreads();
50339 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
50340 wxPyEndAllowThreads(__tstate);
50341 if (PyErr_Occurred()) SWIG_fail;
50342 }
50343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
50344 return resultobj;
50345 fail:
50346 return NULL;
50347 }
50348
50349
50350 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50351 PyObject *resultobj = 0;
50352 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50353 void *argp1 = 0 ;
50354 int res1 = 0 ;
50355 PyObject *swig_obj[1] ;
50356
50357 if (!args) SWIG_fail;
50358 swig_obj[0] = args;
50359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
50360 if (!SWIG_IsOK(res1)) {
50361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50362 }
50363 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50364 {
50365 PyThreadState* __tstate = wxPyBeginAllowThreads();
50366 delete arg1;
50367
50368 wxPyEndAllowThreads(__tstate);
50369 if (PyErr_Occurred()) SWIG_fail;
50370 }
50371 resultobj = SWIG_Py_Void();
50372 return resultobj;
50373 fail:
50374 return NULL;
50375 }
50376
50377
50378 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50379 PyObject *resultobj = 0;
50380 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50381 int result;
50382 void *argp1 = 0 ;
50383 int res1 = 0 ;
50384 PyObject *swig_obj[1] ;
50385
50386 if (!args) SWIG_fail;
50387 swig_obj[0] = args;
50388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50389 if (!SWIG_IsOK(res1)) {
50390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50391 }
50392 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50393 {
50394 PyThreadState* __tstate = wxPyBeginAllowThreads();
50395 result = (int)((wxGBPosition const *)arg1)->GetRow();
50396 wxPyEndAllowThreads(__tstate);
50397 if (PyErr_Occurred()) SWIG_fail;
50398 }
50399 resultobj = SWIG_From_int(static_cast< int >(result));
50400 return resultobj;
50401 fail:
50402 return NULL;
50403 }
50404
50405
50406 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50407 PyObject *resultobj = 0;
50408 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50409 int result;
50410 void *argp1 = 0 ;
50411 int res1 = 0 ;
50412 PyObject *swig_obj[1] ;
50413
50414 if (!args) SWIG_fail;
50415 swig_obj[0] = args;
50416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50417 if (!SWIG_IsOK(res1)) {
50418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50419 }
50420 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50421 {
50422 PyThreadState* __tstate = wxPyBeginAllowThreads();
50423 result = (int)((wxGBPosition const *)arg1)->GetCol();
50424 wxPyEndAllowThreads(__tstate);
50425 if (PyErr_Occurred()) SWIG_fail;
50426 }
50427 resultobj = SWIG_From_int(static_cast< int >(result));
50428 return resultobj;
50429 fail:
50430 return NULL;
50431 }
50432
50433
50434 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50435 PyObject *resultobj = 0;
50436 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50437 int arg2 ;
50438 void *argp1 = 0 ;
50439 int res1 = 0 ;
50440 int val2 ;
50441 int ecode2 = 0 ;
50442 PyObject * obj0 = 0 ;
50443 PyObject * obj1 = 0 ;
50444 char * kwnames[] = {
50445 (char *) "self",(char *) "row", NULL
50446 };
50447
50448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50450 if (!SWIG_IsOK(res1)) {
50451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50452 }
50453 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50454 ecode2 = SWIG_AsVal_int(obj1, &val2);
50455 if (!SWIG_IsOK(ecode2)) {
50456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50457 }
50458 arg2 = static_cast< int >(val2);
50459 {
50460 PyThreadState* __tstate = wxPyBeginAllowThreads();
50461 (arg1)->SetRow(arg2);
50462 wxPyEndAllowThreads(__tstate);
50463 if (PyErr_Occurred()) SWIG_fail;
50464 }
50465 resultobj = SWIG_Py_Void();
50466 return resultobj;
50467 fail:
50468 return NULL;
50469 }
50470
50471
50472 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50473 PyObject *resultobj = 0;
50474 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50475 int arg2 ;
50476 void *argp1 = 0 ;
50477 int res1 = 0 ;
50478 int val2 ;
50479 int ecode2 = 0 ;
50480 PyObject * obj0 = 0 ;
50481 PyObject * obj1 = 0 ;
50482 char * kwnames[] = {
50483 (char *) "self",(char *) "col", NULL
50484 };
50485
50486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50488 if (!SWIG_IsOK(res1)) {
50489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50490 }
50491 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50492 ecode2 = SWIG_AsVal_int(obj1, &val2);
50493 if (!SWIG_IsOK(ecode2)) {
50494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50495 }
50496 arg2 = static_cast< int >(val2);
50497 {
50498 PyThreadState* __tstate = wxPyBeginAllowThreads();
50499 (arg1)->SetCol(arg2);
50500 wxPyEndAllowThreads(__tstate);
50501 if (PyErr_Occurred()) SWIG_fail;
50502 }
50503 resultobj = SWIG_Py_Void();
50504 return resultobj;
50505 fail:
50506 return NULL;
50507 }
50508
50509
50510 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50511 PyObject *resultobj = 0;
50512 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50513 PyObject *arg2 = (PyObject *) 0 ;
50514 bool result;
50515 void *argp1 = 0 ;
50516 int res1 = 0 ;
50517 PyObject * obj0 = 0 ;
50518 PyObject * obj1 = 0 ;
50519 char * kwnames[] = {
50520 (char *) "self",(char *) "other", NULL
50521 };
50522
50523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50525 if (!SWIG_IsOK(res1)) {
50526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50527 }
50528 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50529 arg2 = obj1;
50530 {
50531 result = (bool)wxGBPosition___eq__(arg1,arg2);
50532 if (PyErr_Occurred()) SWIG_fail;
50533 }
50534 {
50535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50536 }
50537 return resultobj;
50538 fail:
50539 return NULL;
50540 }
50541
50542
50543 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50544 PyObject *resultobj = 0;
50545 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50546 PyObject *arg2 = (PyObject *) 0 ;
50547 bool result;
50548 void *argp1 = 0 ;
50549 int res1 = 0 ;
50550 PyObject * obj0 = 0 ;
50551 PyObject * obj1 = 0 ;
50552 char * kwnames[] = {
50553 (char *) "self",(char *) "other", NULL
50554 };
50555
50556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50558 if (!SWIG_IsOK(res1)) {
50559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50560 }
50561 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50562 arg2 = obj1;
50563 {
50564 result = (bool)wxGBPosition___ne__(arg1,arg2);
50565 if (PyErr_Occurred()) SWIG_fail;
50566 }
50567 {
50568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50569 }
50570 return resultobj;
50571 fail:
50572 return NULL;
50573 }
50574
50575
50576 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50577 PyObject *resultobj = 0;
50578 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50579 int arg2 = (int) 0 ;
50580 int arg3 = (int) 0 ;
50581 void *argp1 = 0 ;
50582 int res1 = 0 ;
50583 int val2 ;
50584 int ecode2 = 0 ;
50585 int val3 ;
50586 int ecode3 = 0 ;
50587 PyObject * obj0 = 0 ;
50588 PyObject * obj1 = 0 ;
50589 PyObject * obj2 = 0 ;
50590 char * kwnames[] = {
50591 (char *) "self",(char *) "row",(char *) "col", NULL
50592 };
50593
50594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50596 if (!SWIG_IsOK(res1)) {
50597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50598 }
50599 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50600 if (obj1) {
50601 ecode2 = SWIG_AsVal_int(obj1, &val2);
50602 if (!SWIG_IsOK(ecode2)) {
50603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50604 }
50605 arg2 = static_cast< int >(val2);
50606 }
50607 if (obj2) {
50608 ecode3 = SWIG_AsVal_int(obj2, &val3);
50609 if (!SWIG_IsOK(ecode3)) {
50610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50611 }
50612 arg3 = static_cast< int >(val3);
50613 }
50614 {
50615 PyThreadState* __tstate = wxPyBeginAllowThreads();
50616 wxGBPosition_Set(arg1,arg2,arg3);
50617 wxPyEndAllowThreads(__tstate);
50618 if (PyErr_Occurred()) SWIG_fail;
50619 }
50620 resultobj = SWIG_Py_Void();
50621 return resultobj;
50622 fail:
50623 return NULL;
50624 }
50625
50626
50627 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50628 PyObject *resultobj = 0;
50629 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50630 PyObject *result = 0 ;
50631 void *argp1 = 0 ;
50632 int res1 = 0 ;
50633 PyObject *swig_obj[1] ;
50634
50635 if (!args) SWIG_fail;
50636 swig_obj[0] = args;
50637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50638 if (!SWIG_IsOK(res1)) {
50639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50640 }
50641 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50642 {
50643 PyThreadState* __tstate = wxPyBeginAllowThreads();
50644 result = (PyObject *)wxGBPosition_Get(arg1);
50645 wxPyEndAllowThreads(__tstate);
50646 if (PyErr_Occurred()) SWIG_fail;
50647 }
50648 resultobj = result;
50649 return resultobj;
50650 fail:
50651 return NULL;
50652 }
50653
50654
50655 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50656 PyObject *obj;
50657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50658 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50659 return SWIG_Py_Void();
50660 }
50661
50662 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50663 return SWIG_Python_InitShadowInstance(args);
50664 }
50665
50666 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50667 PyObject *resultobj = 0;
50668 int arg1 = (int) 1 ;
50669 int arg2 = (int) 1 ;
50670 wxGBSpan *result = 0 ;
50671 int val1 ;
50672 int ecode1 = 0 ;
50673 int val2 ;
50674 int ecode2 = 0 ;
50675 PyObject * obj0 = 0 ;
50676 PyObject * obj1 = 0 ;
50677 char * kwnames[] = {
50678 (char *) "rowspan",(char *) "colspan", NULL
50679 };
50680
50681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50682 if (obj0) {
50683 ecode1 = SWIG_AsVal_int(obj0, &val1);
50684 if (!SWIG_IsOK(ecode1)) {
50685 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50686 }
50687 arg1 = static_cast< int >(val1);
50688 }
50689 if (obj1) {
50690 ecode2 = SWIG_AsVal_int(obj1, &val2);
50691 if (!SWIG_IsOK(ecode2)) {
50692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50693 }
50694 arg2 = static_cast< int >(val2);
50695 }
50696 {
50697 PyThreadState* __tstate = wxPyBeginAllowThreads();
50698 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50699 wxPyEndAllowThreads(__tstate);
50700 if (PyErr_Occurred()) SWIG_fail;
50701 }
50702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50703 return resultobj;
50704 fail:
50705 return NULL;
50706 }
50707
50708
50709 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50710 PyObject *resultobj = 0;
50711 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50712 void *argp1 = 0 ;
50713 int res1 = 0 ;
50714 PyObject *swig_obj[1] ;
50715
50716 if (!args) SWIG_fail;
50717 swig_obj[0] = args;
50718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50719 if (!SWIG_IsOK(res1)) {
50720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50721 }
50722 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50723 {
50724 PyThreadState* __tstate = wxPyBeginAllowThreads();
50725 delete arg1;
50726
50727 wxPyEndAllowThreads(__tstate);
50728 if (PyErr_Occurred()) SWIG_fail;
50729 }
50730 resultobj = SWIG_Py_Void();
50731 return resultobj;
50732 fail:
50733 return NULL;
50734 }
50735
50736
50737 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50738 PyObject *resultobj = 0;
50739 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50740 int result;
50741 void *argp1 = 0 ;
50742 int res1 = 0 ;
50743 PyObject *swig_obj[1] ;
50744
50745 if (!args) SWIG_fail;
50746 swig_obj[0] = args;
50747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50748 if (!SWIG_IsOK(res1)) {
50749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50750 }
50751 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50752 {
50753 PyThreadState* __tstate = wxPyBeginAllowThreads();
50754 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50755 wxPyEndAllowThreads(__tstate);
50756 if (PyErr_Occurred()) SWIG_fail;
50757 }
50758 resultobj = SWIG_From_int(static_cast< int >(result));
50759 return resultobj;
50760 fail:
50761 return NULL;
50762 }
50763
50764
50765 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50766 PyObject *resultobj = 0;
50767 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50768 int result;
50769 void *argp1 = 0 ;
50770 int res1 = 0 ;
50771 PyObject *swig_obj[1] ;
50772
50773 if (!args) SWIG_fail;
50774 swig_obj[0] = args;
50775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50776 if (!SWIG_IsOK(res1)) {
50777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50778 }
50779 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50780 {
50781 PyThreadState* __tstate = wxPyBeginAllowThreads();
50782 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50783 wxPyEndAllowThreads(__tstate);
50784 if (PyErr_Occurred()) SWIG_fail;
50785 }
50786 resultobj = SWIG_From_int(static_cast< int >(result));
50787 return resultobj;
50788 fail:
50789 return NULL;
50790 }
50791
50792
50793 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50794 PyObject *resultobj = 0;
50795 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50796 int arg2 ;
50797 void *argp1 = 0 ;
50798 int res1 = 0 ;
50799 int val2 ;
50800 int ecode2 = 0 ;
50801 PyObject * obj0 = 0 ;
50802 PyObject * obj1 = 0 ;
50803 char * kwnames[] = {
50804 (char *) "self",(char *) "rowspan", NULL
50805 };
50806
50807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50809 if (!SWIG_IsOK(res1)) {
50810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50811 }
50812 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50813 ecode2 = SWIG_AsVal_int(obj1, &val2);
50814 if (!SWIG_IsOK(ecode2)) {
50815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50816 }
50817 arg2 = static_cast< int >(val2);
50818 {
50819 PyThreadState* __tstate = wxPyBeginAllowThreads();
50820 (arg1)->SetRowspan(arg2);
50821 wxPyEndAllowThreads(__tstate);
50822 if (PyErr_Occurred()) SWIG_fail;
50823 }
50824 resultobj = SWIG_Py_Void();
50825 return resultobj;
50826 fail:
50827 return NULL;
50828 }
50829
50830
50831 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50832 PyObject *resultobj = 0;
50833 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50834 int arg2 ;
50835 void *argp1 = 0 ;
50836 int res1 = 0 ;
50837 int val2 ;
50838 int ecode2 = 0 ;
50839 PyObject * obj0 = 0 ;
50840 PyObject * obj1 = 0 ;
50841 char * kwnames[] = {
50842 (char *) "self",(char *) "colspan", NULL
50843 };
50844
50845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50847 if (!SWIG_IsOK(res1)) {
50848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50849 }
50850 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50851 ecode2 = SWIG_AsVal_int(obj1, &val2);
50852 if (!SWIG_IsOK(ecode2)) {
50853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50854 }
50855 arg2 = static_cast< int >(val2);
50856 {
50857 PyThreadState* __tstate = wxPyBeginAllowThreads();
50858 (arg1)->SetColspan(arg2);
50859 wxPyEndAllowThreads(__tstate);
50860 if (PyErr_Occurred()) SWIG_fail;
50861 }
50862 resultobj = SWIG_Py_Void();
50863 return resultobj;
50864 fail:
50865 return NULL;
50866 }
50867
50868
50869 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50870 PyObject *resultobj = 0;
50871 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50872 PyObject *arg2 = (PyObject *) 0 ;
50873 bool result;
50874 void *argp1 = 0 ;
50875 int res1 = 0 ;
50876 PyObject * obj0 = 0 ;
50877 PyObject * obj1 = 0 ;
50878 char * kwnames[] = {
50879 (char *) "self",(char *) "other", NULL
50880 };
50881
50882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50884 if (!SWIG_IsOK(res1)) {
50885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50886 }
50887 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50888 arg2 = obj1;
50889 {
50890 result = (bool)wxGBSpan___eq__(arg1,arg2);
50891 if (PyErr_Occurred()) SWIG_fail;
50892 }
50893 {
50894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50895 }
50896 return resultobj;
50897 fail:
50898 return NULL;
50899 }
50900
50901
50902 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50903 PyObject *resultobj = 0;
50904 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50905 PyObject *arg2 = (PyObject *) 0 ;
50906 bool result;
50907 void *argp1 = 0 ;
50908 int res1 = 0 ;
50909 PyObject * obj0 = 0 ;
50910 PyObject * obj1 = 0 ;
50911 char * kwnames[] = {
50912 (char *) "self",(char *) "other", NULL
50913 };
50914
50915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50917 if (!SWIG_IsOK(res1)) {
50918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50919 }
50920 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50921 arg2 = obj1;
50922 {
50923 result = (bool)wxGBSpan___ne__(arg1,arg2);
50924 if (PyErr_Occurred()) SWIG_fail;
50925 }
50926 {
50927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50928 }
50929 return resultobj;
50930 fail:
50931 return NULL;
50932 }
50933
50934
50935 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50936 PyObject *resultobj = 0;
50937 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50938 int arg2 = (int) 1 ;
50939 int arg3 = (int) 1 ;
50940 void *argp1 = 0 ;
50941 int res1 = 0 ;
50942 int val2 ;
50943 int ecode2 = 0 ;
50944 int val3 ;
50945 int ecode3 = 0 ;
50946 PyObject * obj0 = 0 ;
50947 PyObject * obj1 = 0 ;
50948 PyObject * obj2 = 0 ;
50949 char * kwnames[] = {
50950 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
50951 };
50952
50953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50955 if (!SWIG_IsOK(res1)) {
50956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50957 }
50958 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50959 if (obj1) {
50960 ecode2 = SWIG_AsVal_int(obj1, &val2);
50961 if (!SWIG_IsOK(ecode2)) {
50962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
50963 }
50964 arg2 = static_cast< int >(val2);
50965 }
50966 if (obj2) {
50967 ecode3 = SWIG_AsVal_int(obj2, &val3);
50968 if (!SWIG_IsOK(ecode3)) {
50969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
50970 }
50971 arg3 = static_cast< int >(val3);
50972 }
50973 {
50974 PyThreadState* __tstate = wxPyBeginAllowThreads();
50975 wxGBSpan_Set(arg1,arg2,arg3);
50976 wxPyEndAllowThreads(__tstate);
50977 if (PyErr_Occurred()) SWIG_fail;
50978 }
50979 resultobj = SWIG_Py_Void();
50980 return resultobj;
50981 fail:
50982 return NULL;
50983 }
50984
50985
50986 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50987 PyObject *resultobj = 0;
50988 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50989 PyObject *result = 0 ;
50990 void *argp1 = 0 ;
50991 int res1 = 0 ;
50992 PyObject *swig_obj[1] ;
50993
50994 if (!args) SWIG_fail;
50995 swig_obj[0] = args;
50996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50997 if (!SWIG_IsOK(res1)) {
50998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50999 }
51000 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51001 {
51002 PyThreadState* __tstate = wxPyBeginAllowThreads();
51003 result = (PyObject *)wxGBSpan_Get(arg1);
51004 wxPyEndAllowThreads(__tstate);
51005 if (PyErr_Occurred()) SWIG_fail;
51006 }
51007 resultobj = result;
51008 return resultobj;
51009 fail:
51010 return NULL;
51011 }
51012
51013
51014 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51015 PyObject *obj;
51016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51017 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
51018 return SWIG_Py_Void();
51019 }
51020
51021 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51022 return SWIG_Python_InitShadowInstance(args);
51023 }
51024
51025 SWIGINTERN int DefaultSpan_set(PyObject *) {
51026 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
51027 return 1;
51028 }
51029
51030
51031 SWIGINTERN PyObject *DefaultSpan_get(void) {
51032 PyObject *pyobj = 0;
51033
51034 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
51035 return pyobj;
51036 }
51037
51038
51039 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51040 PyObject *resultobj = 0;
51041 wxGBSizerItem *result = 0 ;
51042
51043 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
51044 {
51045 PyThreadState* __tstate = wxPyBeginAllowThreads();
51046 result = (wxGBSizerItem *)new wxGBSizerItem();
51047 wxPyEndAllowThreads(__tstate);
51048 if (PyErr_Occurred()) SWIG_fail;
51049 }
51050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
51051 return resultobj;
51052 fail:
51053 return NULL;
51054 }
51055
51056
51057 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51058 PyObject *resultobj = 0;
51059 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51060 void *argp1 = 0 ;
51061 int res1 = 0 ;
51062 PyObject *swig_obj[1] ;
51063
51064 if (!args) SWIG_fail;
51065 swig_obj[0] = args;
51066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51067 if (!SWIG_IsOK(res1)) {
51068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51069 }
51070 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51071 {
51072 PyThreadState* __tstate = wxPyBeginAllowThreads();
51073 delete arg1;
51074
51075 wxPyEndAllowThreads(__tstate);
51076 if (PyErr_Occurred()) SWIG_fail;
51077 }
51078 resultobj = SWIG_Py_Void();
51079 return resultobj;
51080 fail:
51081 return NULL;
51082 }
51083
51084
51085 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51086 PyObject *resultobj = 0;
51087 wxWindow *arg1 = (wxWindow *) 0 ;
51088 wxGBPosition *arg2 = 0 ;
51089 wxGBSpan *arg3 = 0 ;
51090 int arg4 ;
51091 int arg5 ;
51092 PyObject *arg6 = (PyObject *) NULL ;
51093 wxGBSizerItem *result = 0 ;
51094 void *argp1 = 0 ;
51095 int res1 = 0 ;
51096 wxGBPosition temp2 ;
51097 wxGBSpan temp3 ;
51098 int val4 ;
51099 int ecode4 = 0 ;
51100 int val5 ;
51101 int ecode5 = 0 ;
51102 PyObject * obj0 = 0 ;
51103 PyObject * obj1 = 0 ;
51104 PyObject * obj2 = 0 ;
51105 PyObject * obj3 = 0 ;
51106 PyObject * obj4 = 0 ;
51107 PyObject * obj5 = 0 ;
51108 char * kwnames[] = {
51109 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51110 };
51111
51112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
51114 if (!SWIG_IsOK(res1)) {
51115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
51116 }
51117 arg1 = reinterpret_cast< wxWindow * >(argp1);
51118 {
51119 arg2 = &temp2;
51120 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51121 }
51122 {
51123 arg3 = &temp3;
51124 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51125 }
51126 ecode4 = SWIG_AsVal_int(obj3, &val4);
51127 if (!SWIG_IsOK(ecode4)) {
51128 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
51129 }
51130 arg4 = static_cast< int >(val4);
51131 ecode5 = SWIG_AsVal_int(obj4, &val5);
51132 if (!SWIG_IsOK(ecode5)) {
51133 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
51134 }
51135 arg5 = static_cast< int >(val5);
51136 if (obj5) {
51137 arg6 = obj5;
51138 }
51139 {
51140 PyThreadState* __tstate = wxPyBeginAllowThreads();
51141 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51142 wxPyEndAllowThreads(__tstate);
51143 if (PyErr_Occurred()) SWIG_fail;
51144 }
51145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51146 return resultobj;
51147 fail:
51148 return NULL;
51149 }
51150
51151
51152 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51153 PyObject *resultobj = 0;
51154 wxSizer *arg1 = (wxSizer *) 0 ;
51155 wxGBPosition *arg2 = 0 ;
51156 wxGBSpan *arg3 = 0 ;
51157 int arg4 ;
51158 int arg5 ;
51159 PyObject *arg6 = (PyObject *) NULL ;
51160 wxGBSizerItem *result = 0 ;
51161 int res1 = 0 ;
51162 wxGBPosition temp2 ;
51163 wxGBSpan temp3 ;
51164 int val4 ;
51165 int ecode4 = 0 ;
51166 int val5 ;
51167 int ecode5 = 0 ;
51168 PyObject * obj0 = 0 ;
51169 PyObject * obj1 = 0 ;
51170 PyObject * obj2 = 0 ;
51171 PyObject * obj3 = 0 ;
51172 PyObject * obj4 = 0 ;
51173 PyObject * obj5 = 0 ;
51174 char * kwnames[] = {
51175 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51176 };
51177
51178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51179 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51180 if (!SWIG_IsOK(res1)) {
51181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51182 }
51183 {
51184 arg2 = &temp2;
51185 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51186 }
51187 {
51188 arg3 = &temp3;
51189 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51190 }
51191 ecode4 = SWIG_AsVal_int(obj3, &val4);
51192 if (!SWIG_IsOK(ecode4)) {
51193 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
51194 }
51195 arg4 = static_cast< int >(val4);
51196 ecode5 = SWIG_AsVal_int(obj4, &val5);
51197 if (!SWIG_IsOK(ecode5)) {
51198 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
51199 }
51200 arg5 = static_cast< int >(val5);
51201 if (obj5) {
51202 arg6 = obj5;
51203 }
51204 {
51205 PyThreadState* __tstate = wxPyBeginAllowThreads();
51206 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51207 wxPyEndAllowThreads(__tstate);
51208 if (PyErr_Occurred()) SWIG_fail;
51209 }
51210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51211 return resultobj;
51212 fail:
51213 return NULL;
51214 }
51215
51216
51217 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51218 PyObject *resultobj = 0;
51219 int arg1 ;
51220 int arg2 ;
51221 wxGBPosition *arg3 = 0 ;
51222 wxGBSpan *arg4 = 0 ;
51223 int arg5 ;
51224 int arg6 ;
51225 PyObject *arg7 = (PyObject *) NULL ;
51226 wxGBSizerItem *result = 0 ;
51227 int val1 ;
51228 int ecode1 = 0 ;
51229 int val2 ;
51230 int ecode2 = 0 ;
51231 wxGBPosition temp3 ;
51232 wxGBSpan temp4 ;
51233 int val5 ;
51234 int ecode5 = 0 ;
51235 int val6 ;
51236 int ecode6 = 0 ;
51237 PyObject * obj0 = 0 ;
51238 PyObject * obj1 = 0 ;
51239 PyObject * obj2 = 0 ;
51240 PyObject * obj3 = 0 ;
51241 PyObject * obj4 = 0 ;
51242 PyObject * obj5 = 0 ;
51243 PyObject * obj6 = 0 ;
51244 char * kwnames[] = {
51245 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51246 };
51247
51248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51249 ecode1 = SWIG_AsVal_int(obj0, &val1);
51250 if (!SWIG_IsOK(ecode1)) {
51251 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
51252 }
51253 arg1 = static_cast< int >(val1);
51254 ecode2 = SWIG_AsVal_int(obj1, &val2);
51255 if (!SWIG_IsOK(ecode2)) {
51256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
51257 }
51258 arg2 = static_cast< int >(val2);
51259 {
51260 arg3 = &temp3;
51261 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51262 }
51263 {
51264 arg4 = &temp4;
51265 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51266 }
51267 ecode5 = SWIG_AsVal_int(obj4, &val5);
51268 if (!SWIG_IsOK(ecode5)) {
51269 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
51270 }
51271 arg5 = static_cast< int >(val5);
51272 ecode6 = SWIG_AsVal_int(obj5, &val6);
51273 if (!SWIG_IsOK(ecode6)) {
51274 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
51275 }
51276 arg6 = static_cast< int >(val6);
51277 if (obj6) {
51278 arg7 = obj6;
51279 }
51280 {
51281 PyThreadState* __tstate = wxPyBeginAllowThreads();
51282 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51283 wxPyEndAllowThreads(__tstate);
51284 if (PyErr_Occurred()) SWIG_fail;
51285 }
51286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51287 return resultobj;
51288 fail:
51289 return NULL;
51290 }
51291
51292
51293 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51294 PyObject *resultobj = 0;
51295 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51296 wxGBPosition result;
51297 void *argp1 = 0 ;
51298 int res1 = 0 ;
51299 PyObject *swig_obj[1] ;
51300
51301 if (!args) SWIG_fail;
51302 swig_obj[0] = args;
51303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51304 if (!SWIG_IsOK(res1)) {
51305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51306 }
51307 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51308 {
51309 PyThreadState* __tstate = wxPyBeginAllowThreads();
51310 result = ((wxGBSizerItem const *)arg1)->GetPos();
51311 wxPyEndAllowThreads(__tstate);
51312 if (PyErr_Occurred()) SWIG_fail;
51313 }
51314 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51315 return resultobj;
51316 fail:
51317 return NULL;
51318 }
51319
51320
51321 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51322 PyObject *resultobj = 0;
51323 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51324 wxGBSpan result;
51325 void *argp1 = 0 ;
51326 int res1 = 0 ;
51327 PyObject *swig_obj[1] ;
51328
51329 if (!args) SWIG_fail;
51330 swig_obj[0] = args;
51331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51332 if (!SWIG_IsOK(res1)) {
51333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51334 }
51335 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51336 {
51337 PyThreadState* __tstate = wxPyBeginAllowThreads();
51338 result = ((wxGBSizerItem const *)arg1)->GetSpan();
51339 wxPyEndAllowThreads(__tstate);
51340 if (PyErr_Occurred()) SWIG_fail;
51341 }
51342 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51343 return resultobj;
51344 fail:
51345 return NULL;
51346 }
51347
51348
51349 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51350 PyObject *resultobj = 0;
51351 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51352 wxGBPosition *arg2 = 0 ;
51353 bool result;
51354 void *argp1 = 0 ;
51355 int res1 = 0 ;
51356 wxGBPosition temp2 ;
51357 PyObject * obj0 = 0 ;
51358 PyObject * obj1 = 0 ;
51359 char * kwnames[] = {
51360 (char *) "self",(char *) "pos", NULL
51361 };
51362
51363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
51364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51365 if (!SWIG_IsOK(res1)) {
51366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51367 }
51368 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51369 {
51370 arg2 = &temp2;
51371 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51372 }
51373 {
51374 PyThreadState* __tstate = wxPyBeginAllowThreads();
51375 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
51376 wxPyEndAllowThreads(__tstate);
51377 if (PyErr_Occurred()) SWIG_fail;
51378 }
51379 {
51380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51381 }
51382 return resultobj;
51383 fail:
51384 return NULL;
51385 }
51386
51387
51388 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51389 PyObject *resultobj = 0;
51390 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51391 wxGBSpan *arg2 = 0 ;
51392 bool result;
51393 void *argp1 = 0 ;
51394 int res1 = 0 ;
51395 wxGBSpan temp2 ;
51396 PyObject * obj0 = 0 ;
51397 PyObject * obj1 = 0 ;
51398 char * kwnames[] = {
51399 (char *) "self",(char *) "span", NULL
51400 };
51401
51402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
51403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51404 if (!SWIG_IsOK(res1)) {
51405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51406 }
51407 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51408 {
51409 arg2 = &temp2;
51410 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
51411 }
51412 {
51413 PyThreadState* __tstate = wxPyBeginAllowThreads();
51414 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
51415 wxPyEndAllowThreads(__tstate);
51416 if (PyErr_Occurred()) SWIG_fail;
51417 }
51418 {
51419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51420 }
51421 return resultobj;
51422 fail:
51423 return NULL;
51424 }
51425
51426
51427 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51428 PyObject *resultobj = 0;
51429 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51430 wxGBSizerItem *arg2 = 0 ;
51431 bool result;
51432 void *argp1 = 0 ;
51433 int res1 = 0 ;
51434 void *argp2 = 0 ;
51435 int res2 = 0 ;
51436 PyObject * obj0 = 0 ;
51437 PyObject * obj1 = 0 ;
51438 char * kwnames[] = {
51439 (char *) "self",(char *) "other", NULL
51440 };
51441
51442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51444 if (!SWIG_IsOK(res1)) {
51445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51446 }
51447 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51448 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51449 if (!SWIG_IsOK(res2)) {
51450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51451 }
51452 if (!argp2) {
51453 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51454 }
51455 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51456 {
51457 PyThreadState* __tstate = wxPyBeginAllowThreads();
51458 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51459 wxPyEndAllowThreads(__tstate);
51460 if (PyErr_Occurred()) SWIG_fail;
51461 }
51462 {
51463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51464 }
51465 return resultobj;
51466 fail:
51467 return NULL;
51468 }
51469
51470
51471 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51472 PyObject *resultobj = 0;
51473 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51474 wxGBPosition *arg2 = 0 ;
51475 wxGBSpan *arg3 = 0 ;
51476 bool result;
51477 void *argp1 = 0 ;
51478 int res1 = 0 ;
51479 wxGBPosition temp2 ;
51480 wxGBSpan temp3 ;
51481 PyObject * obj0 = 0 ;
51482 PyObject * obj1 = 0 ;
51483 PyObject * obj2 = 0 ;
51484 char * kwnames[] = {
51485 (char *) "self",(char *) "pos",(char *) "span", NULL
51486 };
51487
51488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51490 if (!SWIG_IsOK(res1)) {
51491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51492 }
51493 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51494 {
51495 arg2 = &temp2;
51496 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51497 }
51498 {
51499 arg3 = &temp3;
51500 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51501 }
51502 {
51503 PyThreadState* __tstate = wxPyBeginAllowThreads();
51504 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51505 wxPyEndAllowThreads(__tstate);
51506 if (PyErr_Occurred()) SWIG_fail;
51507 }
51508 {
51509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51510 }
51511 return resultobj;
51512 fail:
51513 return NULL;
51514 }
51515
51516
51517 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51518 PyObject *resultobj = 0;
51519 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51520 wxGBPosition result;
51521 void *argp1 = 0 ;
51522 int res1 = 0 ;
51523 PyObject *swig_obj[1] ;
51524
51525 if (!args) SWIG_fail;
51526 swig_obj[0] = args;
51527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51528 if (!SWIG_IsOK(res1)) {
51529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51530 }
51531 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51532 {
51533 PyThreadState* __tstate = wxPyBeginAllowThreads();
51534 result = wxGBSizerItem_GetEndPos(arg1);
51535 wxPyEndAllowThreads(__tstate);
51536 if (PyErr_Occurred()) SWIG_fail;
51537 }
51538 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51539 return resultobj;
51540 fail:
51541 return NULL;
51542 }
51543
51544
51545 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51546 PyObject *resultobj = 0;
51547 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51548 wxGridBagSizer *result = 0 ;
51549 void *argp1 = 0 ;
51550 int res1 = 0 ;
51551 PyObject *swig_obj[1] ;
51552
51553 if (!args) SWIG_fail;
51554 swig_obj[0] = args;
51555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51556 if (!SWIG_IsOK(res1)) {
51557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51558 }
51559 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51560 {
51561 PyThreadState* __tstate = wxPyBeginAllowThreads();
51562 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51563 wxPyEndAllowThreads(__tstate);
51564 if (PyErr_Occurred()) SWIG_fail;
51565 }
51566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51567 return resultobj;
51568 fail:
51569 return NULL;
51570 }
51571
51572
51573 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51574 PyObject *resultobj = 0;
51575 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51576 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51577 void *argp1 = 0 ;
51578 int res1 = 0 ;
51579 void *argp2 = 0 ;
51580 int res2 = 0 ;
51581 PyObject * obj0 = 0 ;
51582 PyObject * obj1 = 0 ;
51583 char * kwnames[] = {
51584 (char *) "self",(char *) "sizer", NULL
51585 };
51586
51587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51589 if (!SWIG_IsOK(res1)) {
51590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51591 }
51592 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51593 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51594 if (!SWIG_IsOK(res2)) {
51595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51596 }
51597 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51598 {
51599 PyThreadState* __tstate = wxPyBeginAllowThreads();
51600 (arg1)->SetGBSizer(arg2);
51601 wxPyEndAllowThreads(__tstate);
51602 if (PyErr_Occurred()) SWIG_fail;
51603 }
51604 resultobj = SWIG_Py_Void();
51605 return resultobj;
51606 fail:
51607 return NULL;
51608 }
51609
51610
51611 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51612 PyObject *obj;
51613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51614 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51615 return SWIG_Py_Void();
51616 }
51617
51618 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51619 return SWIG_Python_InitShadowInstance(args);
51620 }
51621
51622 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51623 PyObject *resultobj = 0;
51624 int arg1 = (int) 0 ;
51625 int arg2 = (int) 0 ;
51626 wxGridBagSizer *result = 0 ;
51627 int val1 ;
51628 int ecode1 = 0 ;
51629 int val2 ;
51630 int ecode2 = 0 ;
51631 PyObject * obj0 = 0 ;
51632 PyObject * obj1 = 0 ;
51633 char * kwnames[] = {
51634 (char *) "vgap",(char *) "hgap", NULL
51635 };
51636
51637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51638 if (obj0) {
51639 ecode1 = SWIG_AsVal_int(obj0, &val1);
51640 if (!SWIG_IsOK(ecode1)) {
51641 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51642 }
51643 arg1 = static_cast< int >(val1);
51644 }
51645 if (obj1) {
51646 ecode2 = SWIG_AsVal_int(obj1, &val2);
51647 if (!SWIG_IsOK(ecode2)) {
51648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51649 }
51650 arg2 = static_cast< int >(val2);
51651 }
51652 {
51653 PyThreadState* __tstate = wxPyBeginAllowThreads();
51654 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51655 wxPyEndAllowThreads(__tstate);
51656 if (PyErr_Occurred()) SWIG_fail;
51657 }
51658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51659 return resultobj;
51660 fail:
51661 return NULL;
51662 }
51663
51664
51665 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51666 PyObject *resultobj = 0;
51667 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51668 PyObject *arg2 = (PyObject *) 0 ;
51669 wxGBPosition *arg3 = 0 ;
51670 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51671 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51672 int arg5 = (int) 0 ;
51673 int arg6 = (int) 0 ;
51674 PyObject *arg7 = (PyObject *) NULL ;
51675 wxGBSizerItem *result = 0 ;
51676 void *argp1 = 0 ;
51677 int res1 = 0 ;
51678 wxGBPosition temp3 ;
51679 wxGBSpan temp4 ;
51680 int val5 ;
51681 int ecode5 = 0 ;
51682 int val6 ;
51683 int ecode6 = 0 ;
51684 PyObject * obj0 = 0 ;
51685 PyObject * obj1 = 0 ;
51686 PyObject * obj2 = 0 ;
51687 PyObject * obj3 = 0 ;
51688 PyObject * obj4 = 0 ;
51689 PyObject * obj5 = 0 ;
51690 PyObject * obj6 = 0 ;
51691 char * kwnames[] = {
51692 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51693 };
51694
51695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51697 if (!SWIG_IsOK(res1)) {
51698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51699 }
51700 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51701 arg2 = obj1;
51702 {
51703 arg3 = &temp3;
51704 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51705 }
51706 if (obj3) {
51707 {
51708 arg4 = &temp4;
51709 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51710 }
51711 }
51712 if (obj4) {
51713 ecode5 = SWIG_AsVal_int(obj4, &val5);
51714 if (!SWIG_IsOK(ecode5)) {
51715 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51716 }
51717 arg5 = static_cast< int >(val5);
51718 }
51719 if (obj5) {
51720 ecode6 = SWIG_AsVal_int(obj5, &val6);
51721 if (!SWIG_IsOK(ecode6)) {
51722 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51723 }
51724 arg6 = static_cast< int >(val6);
51725 }
51726 if (obj6) {
51727 arg7 = obj6;
51728 }
51729 {
51730 PyThreadState* __tstate = wxPyBeginAllowThreads();
51731 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51732 wxPyEndAllowThreads(__tstate);
51733 if (PyErr_Occurred()) SWIG_fail;
51734 }
51735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51736 return resultobj;
51737 fail:
51738 return NULL;
51739 }
51740
51741
51742 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51743 PyObject *resultobj = 0;
51744 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51745 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51746 wxGBSizerItem *result = 0 ;
51747 void *argp1 = 0 ;
51748 int res1 = 0 ;
51749 int res2 = 0 ;
51750 PyObject * obj0 = 0 ;
51751 PyObject * obj1 = 0 ;
51752 char * kwnames[] = {
51753 (char *) "self",(char *) "item", NULL
51754 };
51755
51756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51758 if (!SWIG_IsOK(res1)) {
51759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51760 }
51761 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51762 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51763 if (!SWIG_IsOK(res2)) {
51764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51765 }
51766 {
51767 PyThreadState* __tstate = wxPyBeginAllowThreads();
51768 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51769 wxPyEndAllowThreads(__tstate);
51770 if (PyErr_Occurred()) SWIG_fail;
51771 }
51772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51773 return resultobj;
51774 fail:
51775 return NULL;
51776 }
51777
51778
51779 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51780 PyObject *resultobj = 0;
51781 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51782 int arg2 ;
51783 int arg3 ;
51784 wxSize result;
51785 void *argp1 = 0 ;
51786 int res1 = 0 ;
51787 int val2 ;
51788 int ecode2 = 0 ;
51789 int val3 ;
51790 int ecode3 = 0 ;
51791 PyObject * obj0 = 0 ;
51792 PyObject * obj1 = 0 ;
51793 PyObject * obj2 = 0 ;
51794 char * kwnames[] = {
51795 (char *) "self",(char *) "row",(char *) "col", NULL
51796 };
51797
51798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51800 if (!SWIG_IsOK(res1)) {
51801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51802 }
51803 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51804 ecode2 = SWIG_AsVal_int(obj1, &val2);
51805 if (!SWIG_IsOK(ecode2)) {
51806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51807 }
51808 arg2 = static_cast< int >(val2);
51809 ecode3 = SWIG_AsVal_int(obj2, &val3);
51810 if (!SWIG_IsOK(ecode3)) {
51811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51812 }
51813 arg3 = static_cast< int >(val3);
51814 {
51815 PyThreadState* __tstate = wxPyBeginAllowThreads();
51816 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51817 wxPyEndAllowThreads(__tstate);
51818 if (PyErr_Occurred()) SWIG_fail;
51819 }
51820 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51821 return resultobj;
51822 fail:
51823 return NULL;
51824 }
51825
51826
51827 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51828 PyObject *resultobj = 0;
51829 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51830 wxSize result;
51831 void *argp1 = 0 ;
51832 int res1 = 0 ;
51833 PyObject *swig_obj[1] ;
51834
51835 if (!args) SWIG_fail;
51836 swig_obj[0] = args;
51837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51838 if (!SWIG_IsOK(res1)) {
51839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51840 }
51841 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51842 {
51843 PyThreadState* __tstate = wxPyBeginAllowThreads();
51844 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51845 wxPyEndAllowThreads(__tstate);
51846 if (PyErr_Occurred()) SWIG_fail;
51847 }
51848 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51849 return resultobj;
51850 fail:
51851 return NULL;
51852 }
51853
51854
51855 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51856 PyObject *resultobj = 0;
51857 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51858 wxSize *arg2 = 0 ;
51859 void *argp1 = 0 ;
51860 int res1 = 0 ;
51861 wxSize temp2 ;
51862 PyObject * obj0 = 0 ;
51863 PyObject * obj1 = 0 ;
51864 char * kwnames[] = {
51865 (char *) "self",(char *) "sz", NULL
51866 };
51867
51868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51870 if (!SWIG_IsOK(res1)) {
51871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51872 }
51873 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51874 {
51875 arg2 = &temp2;
51876 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51877 }
51878 {
51879 PyThreadState* __tstate = wxPyBeginAllowThreads();
51880 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51881 wxPyEndAllowThreads(__tstate);
51882 if (PyErr_Occurred()) SWIG_fail;
51883 }
51884 resultobj = SWIG_Py_Void();
51885 return resultobj;
51886 fail:
51887 return NULL;
51888 }
51889
51890
51891 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51892 PyObject *resultobj = 0;
51893 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51894 wxWindow *arg2 = (wxWindow *) 0 ;
51895 wxGBPosition result;
51896 void *argp1 = 0 ;
51897 int res1 = 0 ;
51898 void *argp2 = 0 ;
51899 int res2 = 0 ;
51900
51901 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51903 if (!SWIG_IsOK(res1)) {
51904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51905 }
51906 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51907 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51908 if (!SWIG_IsOK(res2)) {
51909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51910 }
51911 arg2 = reinterpret_cast< wxWindow * >(argp2);
51912 {
51913 PyThreadState* __tstate = wxPyBeginAllowThreads();
51914 result = (arg1)->GetItemPosition(arg2);
51915 wxPyEndAllowThreads(__tstate);
51916 if (PyErr_Occurred()) SWIG_fail;
51917 }
51918 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51919 return resultobj;
51920 fail:
51921 return NULL;
51922 }
51923
51924
51925 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51926 PyObject *resultobj = 0;
51927 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51928 wxSizer *arg2 = (wxSizer *) 0 ;
51929 wxGBPosition result;
51930 void *argp1 = 0 ;
51931 int res1 = 0 ;
51932 void *argp2 = 0 ;
51933 int res2 = 0 ;
51934
51935 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51937 if (!SWIG_IsOK(res1)) {
51938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51939 }
51940 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51941 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51942 if (!SWIG_IsOK(res2)) {
51943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51944 }
51945 arg2 = reinterpret_cast< wxSizer * >(argp2);
51946 {
51947 PyThreadState* __tstate = wxPyBeginAllowThreads();
51948 result = (arg1)->GetItemPosition(arg2);
51949 wxPyEndAllowThreads(__tstate);
51950 if (PyErr_Occurred()) SWIG_fail;
51951 }
51952 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51953 return resultobj;
51954 fail:
51955 return NULL;
51956 }
51957
51958
51959 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51960 PyObject *resultobj = 0;
51961 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51962 size_t arg2 ;
51963 wxGBPosition result;
51964 void *argp1 = 0 ;
51965 int res1 = 0 ;
51966 size_t val2 ;
51967 int ecode2 = 0 ;
51968
51969 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51971 if (!SWIG_IsOK(res1)) {
51972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51973 }
51974 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51975 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51976 if (!SWIG_IsOK(ecode2)) {
51977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51978 }
51979 arg2 = static_cast< size_t >(val2);
51980 {
51981 PyThreadState* __tstate = wxPyBeginAllowThreads();
51982 result = (arg1)->GetItemPosition(arg2);
51983 wxPyEndAllowThreads(__tstate);
51984 if (PyErr_Occurred()) SWIG_fail;
51985 }
51986 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51987 return resultobj;
51988 fail:
51989 return NULL;
51990 }
51991
51992
51993 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
51994 int argc;
51995 PyObject *argv[3];
51996
51997 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
51998 --argc;
51999 if (argc == 2) {
52000 int _v = 0;
52001 {
52002 void *vptr = 0;
52003 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52004 _v = SWIG_CheckState(res);
52005 }
52006 if (!_v) goto check_1;
52007 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
52008 }
52009 check_1:
52010
52011 if (argc == 2) {
52012 int _v = 0;
52013 {
52014 void *vptr = 0;
52015 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52016 _v = SWIG_CheckState(res);
52017 }
52018 if (!_v) goto check_2;
52019 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
52020 }
52021 check_2:
52022
52023 if (argc == 2) {
52024 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
52025 }
52026
52027 fail:
52028 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
52029 return NULL;
52030 }
52031
52032
52033 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52034 PyObject *resultobj = 0;
52035 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52036 wxWindow *arg2 = (wxWindow *) 0 ;
52037 wxGBPosition *arg3 = 0 ;
52038 bool result;
52039 void *argp1 = 0 ;
52040 int res1 = 0 ;
52041 void *argp2 = 0 ;
52042 int res2 = 0 ;
52043 wxGBPosition temp3 ;
52044
52045 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52047 if (!SWIG_IsOK(res1)) {
52048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52049 }
52050 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52051 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52052 if (!SWIG_IsOK(res2)) {
52053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52054 }
52055 arg2 = reinterpret_cast< wxWindow * >(argp2);
52056 {
52057 arg3 = &temp3;
52058 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52059 }
52060 {
52061 PyThreadState* __tstate = wxPyBeginAllowThreads();
52062 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52063 wxPyEndAllowThreads(__tstate);
52064 if (PyErr_Occurred()) SWIG_fail;
52065 }
52066 {
52067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52068 }
52069 return resultobj;
52070 fail:
52071 return NULL;
52072 }
52073
52074
52075 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52076 PyObject *resultobj = 0;
52077 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52078 wxSizer *arg2 = (wxSizer *) 0 ;
52079 wxGBPosition *arg3 = 0 ;
52080 bool result;
52081 void *argp1 = 0 ;
52082 int res1 = 0 ;
52083 void *argp2 = 0 ;
52084 int res2 = 0 ;
52085 wxGBPosition temp3 ;
52086
52087 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52089 if (!SWIG_IsOK(res1)) {
52090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52091 }
52092 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52093 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52094 if (!SWIG_IsOK(res2)) {
52095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52096 }
52097 arg2 = reinterpret_cast< wxSizer * >(argp2);
52098 {
52099 arg3 = &temp3;
52100 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52101 }
52102 {
52103 PyThreadState* __tstate = wxPyBeginAllowThreads();
52104 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52105 wxPyEndAllowThreads(__tstate);
52106 if (PyErr_Occurred()) SWIG_fail;
52107 }
52108 {
52109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52110 }
52111 return resultobj;
52112 fail:
52113 return NULL;
52114 }
52115
52116
52117 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52118 PyObject *resultobj = 0;
52119 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52120 size_t arg2 ;
52121 wxGBPosition *arg3 = 0 ;
52122 bool result;
52123 void *argp1 = 0 ;
52124 int res1 = 0 ;
52125 size_t val2 ;
52126 int ecode2 = 0 ;
52127 wxGBPosition temp3 ;
52128
52129 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52131 if (!SWIG_IsOK(res1)) {
52132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52133 }
52134 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52135 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52136 if (!SWIG_IsOK(ecode2)) {
52137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52138 }
52139 arg2 = static_cast< size_t >(val2);
52140 {
52141 arg3 = &temp3;
52142 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52143 }
52144 {
52145 PyThreadState* __tstate = wxPyBeginAllowThreads();
52146 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52147 wxPyEndAllowThreads(__tstate);
52148 if (PyErr_Occurred()) SWIG_fail;
52149 }
52150 {
52151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52152 }
52153 return resultobj;
52154 fail:
52155 return NULL;
52156 }
52157
52158
52159 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
52160 int argc;
52161 PyObject *argv[4];
52162
52163 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
52164 --argc;
52165 if (argc == 3) {
52166 int _v = 0;
52167 {
52168 void *vptr = 0;
52169 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52170 _v = SWIG_CheckState(res);
52171 }
52172 if (!_v) goto check_1;
52173 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
52174 }
52175 check_1:
52176
52177 if (argc == 3) {
52178 int _v = 0;
52179 {
52180 void *vptr = 0;
52181 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52182 _v = SWIG_CheckState(res);
52183 }
52184 if (!_v) goto check_2;
52185 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
52186 }
52187 check_2:
52188
52189 if (argc == 3) {
52190 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
52191 }
52192
52193 fail:
52194 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
52195 return NULL;
52196 }
52197
52198
52199 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52200 PyObject *resultobj = 0;
52201 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52202 wxWindow *arg2 = (wxWindow *) 0 ;
52203 wxGBSpan result;
52204 void *argp1 = 0 ;
52205 int res1 = 0 ;
52206 void *argp2 = 0 ;
52207 int res2 = 0 ;
52208
52209 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52211 if (!SWIG_IsOK(res1)) {
52212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52213 }
52214 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52215 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52216 if (!SWIG_IsOK(res2)) {
52217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52218 }
52219 arg2 = reinterpret_cast< wxWindow * >(argp2);
52220 {
52221 PyThreadState* __tstate = wxPyBeginAllowThreads();
52222 result = (arg1)->GetItemSpan(arg2);
52223 wxPyEndAllowThreads(__tstate);
52224 if (PyErr_Occurred()) SWIG_fail;
52225 }
52226 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52227 return resultobj;
52228 fail:
52229 return NULL;
52230 }
52231
52232
52233 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52234 PyObject *resultobj = 0;
52235 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52236 wxSizer *arg2 = (wxSizer *) 0 ;
52237 wxGBSpan result;
52238 void *argp1 = 0 ;
52239 int res1 = 0 ;
52240 void *argp2 = 0 ;
52241 int res2 = 0 ;
52242
52243 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52245 if (!SWIG_IsOK(res1)) {
52246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52247 }
52248 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52249 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52250 if (!SWIG_IsOK(res2)) {
52251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52252 }
52253 arg2 = reinterpret_cast< wxSizer * >(argp2);
52254 {
52255 PyThreadState* __tstate = wxPyBeginAllowThreads();
52256 result = (arg1)->GetItemSpan(arg2);
52257 wxPyEndAllowThreads(__tstate);
52258 if (PyErr_Occurred()) SWIG_fail;
52259 }
52260 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52261 return resultobj;
52262 fail:
52263 return NULL;
52264 }
52265
52266
52267 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52268 PyObject *resultobj = 0;
52269 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52270 size_t arg2 ;
52271 wxGBSpan result;
52272 void *argp1 = 0 ;
52273 int res1 = 0 ;
52274 size_t val2 ;
52275 int ecode2 = 0 ;
52276
52277 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52279 if (!SWIG_IsOK(res1)) {
52280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52281 }
52282 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52283 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52284 if (!SWIG_IsOK(ecode2)) {
52285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52286 }
52287 arg2 = static_cast< size_t >(val2);
52288 {
52289 PyThreadState* __tstate = wxPyBeginAllowThreads();
52290 result = (arg1)->GetItemSpan(arg2);
52291 wxPyEndAllowThreads(__tstate);
52292 if (PyErr_Occurred()) SWIG_fail;
52293 }
52294 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52295 return resultobj;
52296 fail:
52297 return NULL;
52298 }
52299
52300
52301 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
52302 int argc;
52303 PyObject *argv[3];
52304
52305 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
52306 --argc;
52307 if (argc == 2) {
52308 int _v = 0;
52309 {
52310 void *vptr = 0;
52311 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52312 _v = SWIG_CheckState(res);
52313 }
52314 if (!_v) goto check_1;
52315 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
52316 }
52317 check_1:
52318
52319 if (argc == 2) {
52320 int _v = 0;
52321 {
52322 void *vptr = 0;
52323 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52324 _v = SWIG_CheckState(res);
52325 }
52326 if (!_v) goto check_2;
52327 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
52328 }
52329 check_2:
52330
52331 if (argc == 2) {
52332 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
52333 }
52334
52335 fail:
52336 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
52337 return NULL;
52338 }
52339
52340
52341 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52342 PyObject *resultobj = 0;
52343 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52344 wxWindow *arg2 = (wxWindow *) 0 ;
52345 wxGBSpan *arg3 = 0 ;
52346 bool result;
52347 void *argp1 = 0 ;
52348 int res1 = 0 ;
52349 void *argp2 = 0 ;
52350 int res2 = 0 ;
52351 wxGBSpan temp3 ;
52352
52353 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52355 if (!SWIG_IsOK(res1)) {
52356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52357 }
52358 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52359 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52360 if (!SWIG_IsOK(res2)) {
52361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52362 }
52363 arg2 = reinterpret_cast< wxWindow * >(argp2);
52364 {
52365 arg3 = &temp3;
52366 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52367 }
52368 {
52369 PyThreadState* __tstate = wxPyBeginAllowThreads();
52370 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52371 wxPyEndAllowThreads(__tstate);
52372 if (PyErr_Occurred()) SWIG_fail;
52373 }
52374 {
52375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52376 }
52377 return resultobj;
52378 fail:
52379 return NULL;
52380 }
52381
52382
52383 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52384 PyObject *resultobj = 0;
52385 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52386 wxSizer *arg2 = (wxSizer *) 0 ;
52387 wxGBSpan *arg3 = 0 ;
52388 bool result;
52389 void *argp1 = 0 ;
52390 int res1 = 0 ;
52391 void *argp2 = 0 ;
52392 int res2 = 0 ;
52393 wxGBSpan temp3 ;
52394
52395 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52397 if (!SWIG_IsOK(res1)) {
52398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52399 }
52400 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52401 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52402 if (!SWIG_IsOK(res2)) {
52403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52404 }
52405 arg2 = reinterpret_cast< wxSizer * >(argp2);
52406 {
52407 arg3 = &temp3;
52408 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52409 }
52410 {
52411 PyThreadState* __tstate = wxPyBeginAllowThreads();
52412 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52413 wxPyEndAllowThreads(__tstate);
52414 if (PyErr_Occurred()) SWIG_fail;
52415 }
52416 {
52417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52418 }
52419 return resultobj;
52420 fail:
52421 return NULL;
52422 }
52423
52424
52425 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52426 PyObject *resultobj = 0;
52427 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52428 size_t arg2 ;
52429 wxGBSpan *arg3 = 0 ;
52430 bool result;
52431 void *argp1 = 0 ;
52432 int res1 = 0 ;
52433 size_t val2 ;
52434 int ecode2 = 0 ;
52435 wxGBSpan temp3 ;
52436
52437 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52439 if (!SWIG_IsOK(res1)) {
52440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52441 }
52442 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52443 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52444 if (!SWIG_IsOK(ecode2)) {
52445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52446 }
52447 arg2 = static_cast< size_t >(val2);
52448 {
52449 arg3 = &temp3;
52450 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52451 }
52452 {
52453 PyThreadState* __tstate = wxPyBeginAllowThreads();
52454 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52455 wxPyEndAllowThreads(__tstate);
52456 if (PyErr_Occurred()) SWIG_fail;
52457 }
52458 {
52459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52460 }
52461 return resultobj;
52462 fail:
52463 return NULL;
52464 }
52465
52466
52467 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52468 int argc;
52469 PyObject *argv[4];
52470
52471 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52472 --argc;
52473 if (argc == 3) {
52474 int _v = 0;
52475 {
52476 void *vptr = 0;
52477 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52478 _v = SWIG_CheckState(res);
52479 }
52480 if (!_v) goto check_1;
52481 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52482 }
52483 check_1:
52484
52485 if (argc == 3) {
52486 int _v = 0;
52487 {
52488 void *vptr = 0;
52489 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52490 _v = SWIG_CheckState(res);
52491 }
52492 if (!_v) goto check_2;
52493 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52494 }
52495 check_2:
52496
52497 if (argc == 3) {
52498 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52499 }
52500
52501 fail:
52502 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52503 return NULL;
52504 }
52505
52506
52507 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52508 PyObject *resultobj = 0;
52509 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52510 wxWindow *arg2 = (wxWindow *) 0 ;
52511 wxGBSizerItem *result = 0 ;
52512 void *argp1 = 0 ;
52513 int res1 = 0 ;
52514 void *argp2 = 0 ;
52515 int res2 = 0 ;
52516
52517 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52519 if (!SWIG_IsOK(res1)) {
52520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52521 }
52522 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52523 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52524 if (!SWIG_IsOK(res2)) {
52525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52526 }
52527 arg2 = reinterpret_cast< wxWindow * >(argp2);
52528 {
52529 PyThreadState* __tstate = wxPyBeginAllowThreads();
52530 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52531 wxPyEndAllowThreads(__tstate);
52532 if (PyErr_Occurred()) SWIG_fail;
52533 }
52534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52535 return resultobj;
52536 fail:
52537 return NULL;
52538 }
52539
52540
52541 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52542 PyObject *resultobj = 0;
52543 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52544 wxSizer *arg2 = (wxSizer *) 0 ;
52545 wxGBSizerItem *result = 0 ;
52546 void *argp1 = 0 ;
52547 int res1 = 0 ;
52548 void *argp2 = 0 ;
52549 int res2 = 0 ;
52550
52551 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52553 if (!SWIG_IsOK(res1)) {
52554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52555 }
52556 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52557 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52558 if (!SWIG_IsOK(res2)) {
52559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52560 }
52561 arg2 = reinterpret_cast< wxSizer * >(argp2);
52562 {
52563 PyThreadState* __tstate = wxPyBeginAllowThreads();
52564 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52565 wxPyEndAllowThreads(__tstate);
52566 if (PyErr_Occurred()) SWIG_fail;
52567 }
52568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52569 return resultobj;
52570 fail:
52571 return NULL;
52572 }
52573
52574
52575 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52576 int argc;
52577 PyObject *argv[3];
52578
52579 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52580 --argc;
52581 if (argc == 2) {
52582 int _v = 0;
52583 {
52584 void *vptr = 0;
52585 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52586 _v = SWIG_CheckState(res);
52587 }
52588 if (!_v) goto check_1;
52589 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52590 }
52591 check_1:
52592
52593 if (argc == 2) {
52594 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52595 }
52596
52597 fail:
52598 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52599 return NULL;
52600 }
52601
52602
52603 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52604 PyObject *resultobj = 0;
52605 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52606 wxGBPosition *arg2 = 0 ;
52607 wxGBSizerItem *result = 0 ;
52608 void *argp1 = 0 ;
52609 int res1 = 0 ;
52610 wxGBPosition temp2 ;
52611 PyObject * obj0 = 0 ;
52612 PyObject * obj1 = 0 ;
52613 char * kwnames[] = {
52614 (char *) "self",(char *) "pos", NULL
52615 };
52616
52617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52619 if (!SWIG_IsOK(res1)) {
52620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52621 }
52622 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52623 {
52624 arg2 = &temp2;
52625 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52626 }
52627 {
52628 PyThreadState* __tstate = wxPyBeginAllowThreads();
52629 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52630 wxPyEndAllowThreads(__tstate);
52631 if (PyErr_Occurred()) SWIG_fail;
52632 }
52633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52634 return resultobj;
52635 fail:
52636 return NULL;
52637 }
52638
52639
52640 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52641 PyObject *resultobj = 0;
52642 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52643 wxPoint *arg2 = 0 ;
52644 wxGBSizerItem *result = 0 ;
52645 void *argp1 = 0 ;
52646 int res1 = 0 ;
52647 wxPoint temp2 ;
52648 PyObject * obj0 = 0 ;
52649 PyObject * obj1 = 0 ;
52650 char * kwnames[] = {
52651 (char *) "self",(char *) "pt", NULL
52652 };
52653
52654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52656 if (!SWIG_IsOK(res1)) {
52657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52658 }
52659 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52660 {
52661 arg2 = &temp2;
52662 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52663 }
52664 {
52665 PyThreadState* __tstate = wxPyBeginAllowThreads();
52666 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52667 wxPyEndAllowThreads(__tstate);
52668 if (PyErr_Occurred()) SWIG_fail;
52669 }
52670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52671 return resultobj;
52672 fail:
52673 return NULL;
52674 }
52675
52676
52677 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52678 PyObject *resultobj = 0;
52679 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52680 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52681 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52682 bool result;
52683 void *argp1 = 0 ;
52684 int res1 = 0 ;
52685 void *argp2 = 0 ;
52686 int res2 = 0 ;
52687 void *argp3 = 0 ;
52688 int res3 = 0 ;
52689 PyObject * obj0 = 0 ;
52690 PyObject * obj1 = 0 ;
52691 PyObject * obj2 = 0 ;
52692 char * kwnames[] = {
52693 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52694 };
52695
52696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52698 if (!SWIG_IsOK(res1)) {
52699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52700 }
52701 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52702 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52703 if (!SWIG_IsOK(res2)) {
52704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52705 }
52706 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52707 if (obj2) {
52708 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52709 if (!SWIG_IsOK(res3)) {
52710 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52711 }
52712 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52713 }
52714 {
52715 PyThreadState* __tstate = wxPyBeginAllowThreads();
52716 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52717 wxPyEndAllowThreads(__tstate);
52718 if (PyErr_Occurred()) SWIG_fail;
52719 }
52720 {
52721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52722 }
52723 return resultobj;
52724 fail:
52725 return NULL;
52726 }
52727
52728
52729 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52730 PyObject *resultobj = 0;
52731 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52732 wxGBPosition *arg2 = 0 ;
52733 wxGBSpan *arg3 = 0 ;
52734 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52735 bool result;
52736 void *argp1 = 0 ;
52737 int res1 = 0 ;
52738 wxGBPosition temp2 ;
52739 wxGBSpan temp3 ;
52740 void *argp4 = 0 ;
52741 int res4 = 0 ;
52742 PyObject * obj0 = 0 ;
52743 PyObject * obj1 = 0 ;
52744 PyObject * obj2 = 0 ;
52745 PyObject * obj3 = 0 ;
52746 char * kwnames[] = {
52747 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52748 };
52749
52750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52752 if (!SWIG_IsOK(res1)) {
52753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52754 }
52755 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52756 {
52757 arg2 = &temp2;
52758 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52759 }
52760 {
52761 arg3 = &temp3;
52762 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52763 }
52764 if (obj3) {
52765 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52766 if (!SWIG_IsOK(res4)) {
52767 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52768 }
52769 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52770 }
52771 {
52772 PyThreadState* __tstate = wxPyBeginAllowThreads();
52773 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52774 wxPyEndAllowThreads(__tstate);
52775 if (PyErr_Occurred()) SWIG_fail;
52776 }
52777 {
52778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52779 }
52780 return resultobj;
52781 fail:
52782 return NULL;
52783 }
52784
52785
52786 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52787 PyObject *obj;
52788 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52789 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52790 return SWIG_Py_Void();
52791 }
52792
52793 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52794 return SWIG_Python_InitShadowInstance(args);
52795 }
52796
52797 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52798 PyObject *resultobj = 0;
52799 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52800 wxRelationship arg2 ;
52801 wxWindow *arg3 = (wxWindow *) 0 ;
52802 wxEdge arg4 ;
52803 int arg5 = (int) 0 ;
52804 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52805 void *argp1 = 0 ;
52806 int res1 = 0 ;
52807 int val2 ;
52808 int ecode2 = 0 ;
52809 void *argp3 = 0 ;
52810 int res3 = 0 ;
52811 int val4 ;
52812 int ecode4 = 0 ;
52813 int val5 ;
52814 int ecode5 = 0 ;
52815 int val6 ;
52816 int ecode6 = 0 ;
52817 PyObject * obj0 = 0 ;
52818 PyObject * obj1 = 0 ;
52819 PyObject * obj2 = 0 ;
52820 PyObject * obj3 = 0 ;
52821 PyObject * obj4 = 0 ;
52822 PyObject * obj5 = 0 ;
52823 char * kwnames[] = {
52824 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52825 };
52826
52827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52829 if (!SWIG_IsOK(res1)) {
52830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52831 }
52832 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52833 ecode2 = SWIG_AsVal_int(obj1, &val2);
52834 if (!SWIG_IsOK(ecode2)) {
52835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52836 }
52837 arg2 = static_cast< wxRelationship >(val2);
52838 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52839 if (!SWIG_IsOK(res3)) {
52840 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52841 }
52842 arg3 = reinterpret_cast< wxWindow * >(argp3);
52843 ecode4 = SWIG_AsVal_int(obj3, &val4);
52844 if (!SWIG_IsOK(ecode4)) {
52845 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52846 }
52847 arg4 = static_cast< wxEdge >(val4);
52848 if (obj4) {
52849 ecode5 = SWIG_AsVal_int(obj4, &val5);
52850 if (!SWIG_IsOK(ecode5)) {
52851 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52852 }
52853 arg5 = static_cast< int >(val5);
52854 }
52855 if (obj5) {
52856 ecode6 = SWIG_AsVal_int(obj5, &val6);
52857 if (!SWIG_IsOK(ecode6)) {
52858 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52859 }
52860 arg6 = static_cast< int >(val6);
52861 }
52862 {
52863 PyThreadState* __tstate = wxPyBeginAllowThreads();
52864 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52865 wxPyEndAllowThreads(__tstate);
52866 if (PyErr_Occurred()) SWIG_fail;
52867 }
52868 resultobj = SWIG_Py_Void();
52869 return resultobj;
52870 fail:
52871 return NULL;
52872 }
52873
52874
52875 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52876 PyObject *resultobj = 0;
52877 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52878 wxWindow *arg2 = (wxWindow *) 0 ;
52879 int arg3 = (int) 0 ;
52880 void *argp1 = 0 ;
52881 int res1 = 0 ;
52882 void *argp2 = 0 ;
52883 int res2 = 0 ;
52884 int val3 ;
52885 int ecode3 = 0 ;
52886 PyObject * obj0 = 0 ;
52887 PyObject * obj1 = 0 ;
52888 PyObject * obj2 = 0 ;
52889 char * kwnames[] = {
52890 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52891 };
52892
52893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52895 if (!SWIG_IsOK(res1)) {
52896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52897 }
52898 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52899 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52900 if (!SWIG_IsOK(res2)) {
52901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52902 }
52903 arg2 = reinterpret_cast< wxWindow * >(argp2);
52904 if (obj2) {
52905 ecode3 = SWIG_AsVal_int(obj2, &val3);
52906 if (!SWIG_IsOK(ecode3)) {
52907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
52908 }
52909 arg3 = static_cast< int >(val3);
52910 }
52911 {
52912 PyThreadState* __tstate = wxPyBeginAllowThreads();
52913 (arg1)->LeftOf(arg2,arg3);
52914 wxPyEndAllowThreads(__tstate);
52915 if (PyErr_Occurred()) SWIG_fail;
52916 }
52917 resultobj = SWIG_Py_Void();
52918 return resultobj;
52919 fail:
52920 return NULL;
52921 }
52922
52923
52924 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52925 PyObject *resultobj = 0;
52926 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52927 wxWindow *arg2 = (wxWindow *) 0 ;
52928 int arg3 = (int) 0 ;
52929 void *argp1 = 0 ;
52930 int res1 = 0 ;
52931 void *argp2 = 0 ;
52932 int res2 = 0 ;
52933 int val3 ;
52934 int ecode3 = 0 ;
52935 PyObject * obj0 = 0 ;
52936 PyObject * obj1 = 0 ;
52937 PyObject * obj2 = 0 ;
52938 char * kwnames[] = {
52939 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52940 };
52941
52942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52944 if (!SWIG_IsOK(res1)) {
52945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52946 }
52947 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52948 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52949 if (!SWIG_IsOK(res2)) {
52950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52951 }
52952 arg2 = reinterpret_cast< wxWindow * >(argp2);
52953 if (obj2) {
52954 ecode3 = SWIG_AsVal_int(obj2, &val3);
52955 if (!SWIG_IsOK(ecode3)) {
52956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
52957 }
52958 arg3 = static_cast< int >(val3);
52959 }
52960 {
52961 PyThreadState* __tstate = wxPyBeginAllowThreads();
52962 (arg1)->RightOf(arg2,arg3);
52963 wxPyEndAllowThreads(__tstate);
52964 if (PyErr_Occurred()) SWIG_fail;
52965 }
52966 resultobj = SWIG_Py_Void();
52967 return resultobj;
52968 fail:
52969 return NULL;
52970 }
52971
52972
52973 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52974 PyObject *resultobj = 0;
52975 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52976 wxWindow *arg2 = (wxWindow *) 0 ;
52977 int arg3 = (int) 0 ;
52978 void *argp1 = 0 ;
52979 int res1 = 0 ;
52980 void *argp2 = 0 ;
52981 int res2 = 0 ;
52982 int val3 ;
52983 int ecode3 = 0 ;
52984 PyObject * obj0 = 0 ;
52985 PyObject * obj1 = 0 ;
52986 PyObject * obj2 = 0 ;
52987 char * kwnames[] = {
52988 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52989 };
52990
52991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52993 if (!SWIG_IsOK(res1)) {
52994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52995 }
52996 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52997 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52998 if (!SWIG_IsOK(res2)) {
52999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
53000 }
53001 arg2 = reinterpret_cast< wxWindow * >(argp2);
53002 if (obj2) {
53003 ecode3 = SWIG_AsVal_int(obj2, &val3);
53004 if (!SWIG_IsOK(ecode3)) {
53005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
53006 }
53007 arg3 = static_cast< int >(val3);
53008 }
53009 {
53010 PyThreadState* __tstate = wxPyBeginAllowThreads();
53011 (arg1)->Above(arg2,arg3);
53012 wxPyEndAllowThreads(__tstate);
53013 if (PyErr_Occurred()) SWIG_fail;
53014 }
53015 resultobj = SWIG_Py_Void();
53016 return resultobj;
53017 fail:
53018 return NULL;
53019 }
53020
53021
53022 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53023 PyObject *resultobj = 0;
53024 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53025 wxWindow *arg2 = (wxWindow *) 0 ;
53026 int arg3 = (int) 0 ;
53027 void *argp1 = 0 ;
53028 int res1 = 0 ;
53029 void *argp2 = 0 ;
53030 int res2 = 0 ;
53031 int val3 ;
53032 int ecode3 = 0 ;
53033 PyObject * obj0 = 0 ;
53034 PyObject * obj1 = 0 ;
53035 PyObject * obj2 = 0 ;
53036 char * kwnames[] = {
53037 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53038 };
53039
53040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53042 if (!SWIG_IsOK(res1)) {
53043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53044 }
53045 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53046 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53047 if (!SWIG_IsOK(res2)) {
53048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
53049 }
53050 arg2 = reinterpret_cast< wxWindow * >(argp2);
53051 if (obj2) {
53052 ecode3 = SWIG_AsVal_int(obj2, &val3);
53053 if (!SWIG_IsOK(ecode3)) {
53054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
53055 }
53056 arg3 = static_cast< int >(val3);
53057 }
53058 {
53059 PyThreadState* __tstate = wxPyBeginAllowThreads();
53060 (arg1)->Below(arg2,arg3);
53061 wxPyEndAllowThreads(__tstate);
53062 if (PyErr_Occurred()) SWIG_fail;
53063 }
53064 resultobj = SWIG_Py_Void();
53065 return resultobj;
53066 fail:
53067 return NULL;
53068 }
53069
53070
53071 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53072 PyObject *resultobj = 0;
53073 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53074 wxWindow *arg2 = (wxWindow *) 0 ;
53075 wxEdge arg3 ;
53076 int arg4 = (int) 0 ;
53077 void *argp1 = 0 ;
53078 int res1 = 0 ;
53079 void *argp2 = 0 ;
53080 int res2 = 0 ;
53081 int val3 ;
53082 int ecode3 = 0 ;
53083 int val4 ;
53084 int ecode4 = 0 ;
53085 PyObject * obj0 = 0 ;
53086 PyObject * obj1 = 0 ;
53087 PyObject * obj2 = 0 ;
53088 PyObject * obj3 = 0 ;
53089 char * kwnames[] = {
53090 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
53091 };
53092
53093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53095 if (!SWIG_IsOK(res1)) {
53096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53097 }
53098 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53099 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53100 if (!SWIG_IsOK(res2)) {
53101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
53102 }
53103 arg2 = reinterpret_cast< wxWindow * >(argp2);
53104 ecode3 = SWIG_AsVal_int(obj2, &val3);
53105 if (!SWIG_IsOK(ecode3)) {
53106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
53107 }
53108 arg3 = static_cast< wxEdge >(val3);
53109 if (obj3) {
53110 ecode4 = SWIG_AsVal_int(obj3, &val4);
53111 if (!SWIG_IsOK(ecode4)) {
53112 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
53113 }
53114 arg4 = static_cast< int >(val4);
53115 }
53116 {
53117 PyThreadState* __tstate = wxPyBeginAllowThreads();
53118 (arg1)->SameAs(arg2,arg3,arg4);
53119 wxPyEndAllowThreads(__tstate);
53120 if (PyErr_Occurred()) SWIG_fail;
53121 }
53122 resultobj = SWIG_Py_Void();
53123 return resultobj;
53124 fail:
53125 return NULL;
53126 }
53127
53128
53129 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53130 PyObject *resultobj = 0;
53131 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53132 wxWindow *arg2 = (wxWindow *) 0 ;
53133 wxEdge arg3 ;
53134 int arg4 ;
53135 void *argp1 = 0 ;
53136 int res1 = 0 ;
53137 void *argp2 = 0 ;
53138 int res2 = 0 ;
53139 int val3 ;
53140 int ecode3 = 0 ;
53141 int val4 ;
53142 int ecode4 = 0 ;
53143 PyObject * obj0 = 0 ;
53144 PyObject * obj1 = 0 ;
53145 PyObject * obj2 = 0 ;
53146 PyObject * obj3 = 0 ;
53147 char * kwnames[] = {
53148 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
53149 };
53150
53151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53153 if (!SWIG_IsOK(res1)) {
53154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53155 }
53156 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53157 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53158 if (!SWIG_IsOK(res2)) {
53159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53160 }
53161 arg2 = reinterpret_cast< wxWindow * >(argp2);
53162 ecode3 = SWIG_AsVal_int(obj2, &val3);
53163 if (!SWIG_IsOK(ecode3)) {
53164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
53165 }
53166 arg3 = static_cast< wxEdge >(val3);
53167 ecode4 = SWIG_AsVal_int(obj3, &val4);
53168 if (!SWIG_IsOK(ecode4)) {
53169 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
53170 }
53171 arg4 = static_cast< int >(val4);
53172 {
53173 PyThreadState* __tstate = wxPyBeginAllowThreads();
53174 (arg1)->PercentOf(arg2,arg3,arg4);
53175 wxPyEndAllowThreads(__tstate);
53176 if (PyErr_Occurred()) SWIG_fail;
53177 }
53178 resultobj = SWIG_Py_Void();
53179 return resultobj;
53180 fail:
53181 return NULL;
53182 }
53183
53184
53185 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53186 PyObject *resultobj = 0;
53187 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53188 int arg2 ;
53189 void *argp1 = 0 ;
53190 int res1 = 0 ;
53191 int val2 ;
53192 int ecode2 = 0 ;
53193 PyObject * obj0 = 0 ;
53194 PyObject * obj1 = 0 ;
53195 char * kwnames[] = {
53196 (char *) "self",(char *) "val", NULL
53197 };
53198
53199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
53200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53201 if (!SWIG_IsOK(res1)) {
53202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53203 }
53204 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53205 ecode2 = SWIG_AsVal_int(obj1, &val2);
53206 if (!SWIG_IsOK(ecode2)) {
53207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
53208 }
53209 arg2 = static_cast< int >(val2);
53210 {
53211 PyThreadState* __tstate = wxPyBeginAllowThreads();
53212 (arg1)->Absolute(arg2);
53213 wxPyEndAllowThreads(__tstate);
53214 if (PyErr_Occurred()) SWIG_fail;
53215 }
53216 resultobj = SWIG_Py_Void();
53217 return resultobj;
53218 fail:
53219 return NULL;
53220 }
53221
53222
53223 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53224 PyObject *resultobj = 0;
53225 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53226 void *argp1 = 0 ;
53227 int res1 = 0 ;
53228 PyObject *swig_obj[1] ;
53229
53230 if (!args) SWIG_fail;
53231 swig_obj[0] = args;
53232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53233 if (!SWIG_IsOK(res1)) {
53234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53235 }
53236 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53237 {
53238 PyThreadState* __tstate = wxPyBeginAllowThreads();
53239 (arg1)->Unconstrained();
53240 wxPyEndAllowThreads(__tstate);
53241 if (PyErr_Occurred()) SWIG_fail;
53242 }
53243 resultobj = SWIG_Py_Void();
53244 return resultobj;
53245 fail:
53246 return NULL;
53247 }
53248
53249
53250 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53251 PyObject *resultobj = 0;
53252 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53253 void *argp1 = 0 ;
53254 int res1 = 0 ;
53255 PyObject *swig_obj[1] ;
53256
53257 if (!args) SWIG_fail;
53258 swig_obj[0] = args;
53259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53260 if (!SWIG_IsOK(res1)) {
53261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53262 }
53263 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53264 {
53265 PyThreadState* __tstate = wxPyBeginAllowThreads();
53266 (arg1)->AsIs();
53267 wxPyEndAllowThreads(__tstate);
53268 if (PyErr_Occurred()) SWIG_fail;
53269 }
53270 resultobj = SWIG_Py_Void();
53271 return resultobj;
53272 fail:
53273 return NULL;
53274 }
53275
53276
53277 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53278 PyObject *resultobj = 0;
53279 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53280 wxWindow *result = 0 ;
53281 void *argp1 = 0 ;
53282 int res1 = 0 ;
53283 PyObject *swig_obj[1] ;
53284
53285 if (!args) SWIG_fail;
53286 swig_obj[0] = args;
53287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53288 if (!SWIG_IsOK(res1)) {
53289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53290 }
53291 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53292 {
53293 PyThreadState* __tstate = wxPyBeginAllowThreads();
53294 result = (wxWindow *)(arg1)->GetOtherWindow();
53295 wxPyEndAllowThreads(__tstate);
53296 if (PyErr_Occurred()) SWIG_fail;
53297 }
53298 {
53299 resultobj = wxPyMake_wxObject(result, 0);
53300 }
53301 return resultobj;
53302 fail:
53303 return NULL;
53304 }
53305
53306
53307 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53308 PyObject *resultobj = 0;
53309 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53310 wxEdge result;
53311 void *argp1 = 0 ;
53312 int res1 = 0 ;
53313 PyObject *swig_obj[1] ;
53314
53315 if (!args) SWIG_fail;
53316 swig_obj[0] = args;
53317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53318 if (!SWIG_IsOK(res1)) {
53319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53320 }
53321 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53322 {
53323 PyThreadState* __tstate = wxPyBeginAllowThreads();
53324 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
53325 wxPyEndAllowThreads(__tstate);
53326 if (PyErr_Occurred()) SWIG_fail;
53327 }
53328 resultobj = SWIG_From_int(static_cast< int >(result));
53329 return resultobj;
53330 fail:
53331 return NULL;
53332 }
53333
53334
53335 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53336 PyObject *resultobj = 0;
53337 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53338 wxEdge arg2 ;
53339 void *argp1 = 0 ;
53340 int res1 = 0 ;
53341 int val2 ;
53342 int ecode2 = 0 ;
53343 PyObject * obj0 = 0 ;
53344 PyObject * obj1 = 0 ;
53345 char * kwnames[] = {
53346 (char *) "self",(char *) "which", NULL
53347 };
53348
53349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
53350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53351 if (!SWIG_IsOK(res1)) {
53352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53353 }
53354 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53355 ecode2 = SWIG_AsVal_int(obj1, &val2);
53356 if (!SWIG_IsOK(ecode2)) {
53357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53358 }
53359 arg2 = static_cast< wxEdge >(val2);
53360 {
53361 PyThreadState* __tstate = wxPyBeginAllowThreads();
53362 (arg1)->SetEdge(arg2);
53363 wxPyEndAllowThreads(__tstate);
53364 if (PyErr_Occurred()) SWIG_fail;
53365 }
53366 resultobj = SWIG_Py_Void();
53367 return resultobj;
53368 fail:
53369 return NULL;
53370 }
53371
53372
53373 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53374 PyObject *resultobj = 0;
53375 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53376 int arg2 ;
53377 void *argp1 = 0 ;
53378 int res1 = 0 ;
53379 int val2 ;
53380 int ecode2 = 0 ;
53381 PyObject * obj0 = 0 ;
53382 PyObject * obj1 = 0 ;
53383 char * kwnames[] = {
53384 (char *) "self",(char *) "v", NULL
53385 };
53386
53387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
53388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53389 if (!SWIG_IsOK(res1)) {
53390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53391 }
53392 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53393 ecode2 = SWIG_AsVal_int(obj1, &val2);
53394 if (!SWIG_IsOK(ecode2)) {
53395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
53396 }
53397 arg2 = static_cast< int >(val2);
53398 {
53399 PyThreadState* __tstate = wxPyBeginAllowThreads();
53400 (arg1)->SetValue(arg2);
53401 wxPyEndAllowThreads(__tstate);
53402 if (PyErr_Occurred()) SWIG_fail;
53403 }
53404 resultobj = SWIG_Py_Void();
53405 return resultobj;
53406 fail:
53407 return NULL;
53408 }
53409
53410
53411 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53412 PyObject *resultobj = 0;
53413 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53414 int result;
53415 void *argp1 = 0 ;
53416 int res1 = 0 ;
53417 PyObject *swig_obj[1] ;
53418
53419 if (!args) SWIG_fail;
53420 swig_obj[0] = args;
53421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53422 if (!SWIG_IsOK(res1)) {
53423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53424 }
53425 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53426 {
53427 PyThreadState* __tstate = wxPyBeginAllowThreads();
53428 result = (int)(arg1)->GetMargin();
53429 wxPyEndAllowThreads(__tstate);
53430 if (PyErr_Occurred()) SWIG_fail;
53431 }
53432 resultobj = SWIG_From_int(static_cast< int >(result));
53433 return resultobj;
53434 fail:
53435 return NULL;
53436 }
53437
53438
53439 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53440 PyObject *resultobj = 0;
53441 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53442 int arg2 ;
53443 void *argp1 = 0 ;
53444 int res1 = 0 ;
53445 int val2 ;
53446 int ecode2 = 0 ;
53447 PyObject * obj0 = 0 ;
53448 PyObject * obj1 = 0 ;
53449 char * kwnames[] = {
53450 (char *) "self",(char *) "m", NULL
53451 };
53452
53453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53455 if (!SWIG_IsOK(res1)) {
53456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53457 }
53458 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53459 ecode2 = SWIG_AsVal_int(obj1, &val2);
53460 if (!SWIG_IsOK(ecode2)) {
53461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53462 }
53463 arg2 = static_cast< int >(val2);
53464 {
53465 PyThreadState* __tstate = wxPyBeginAllowThreads();
53466 (arg1)->SetMargin(arg2);
53467 wxPyEndAllowThreads(__tstate);
53468 if (PyErr_Occurred()) SWIG_fail;
53469 }
53470 resultobj = SWIG_Py_Void();
53471 return resultobj;
53472 fail:
53473 return NULL;
53474 }
53475
53476
53477 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53478 PyObject *resultobj = 0;
53479 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53480 int result;
53481 void *argp1 = 0 ;
53482 int res1 = 0 ;
53483 PyObject *swig_obj[1] ;
53484
53485 if (!args) SWIG_fail;
53486 swig_obj[0] = args;
53487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53488 if (!SWIG_IsOK(res1)) {
53489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53490 }
53491 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53492 {
53493 PyThreadState* __tstate = wxPyBeginAllowThreads();
53494 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53495 wxPyEndAllowThreads(__tstate);
53496 if (PyErr_Occurred()) SWIG_fail;
53497 }
53498 resultobj = SWIG_From_int(static_cast< int >(result));
53499 return resultobj;
53500 fail:
53501 return NULL;
53502 }
53503
53504
53505 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53506 PyObject *resultobj = 0;
53507 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53508 int result;
53509 void *argp1 = 0 ;
53510 int res1 = 0 ;
53511 PyObject *swig_obj[1] ;
53512
53513 if (!args) SWIG_fail;
53514 swig_obj[0] = args;
53515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53516 if (!SWIG_IsOK(res1)) {
53517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53518 }
53519 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53520 {
53521 PyThreadState* __tstate = wxPyBeginAllowThreads();
53522 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53523 wxPyEndAllowThreads(__tstate);
53524 if (PyErr_Occurred()) SWIG_fail;
53525 }
53526 resultobj = SWIG_From_int(static_cast< int >(result));
53527 return resultobj;
53528 fail:
53529 return NULL;
53530 }
53531
53532
53533 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53534 PyObject *resultobj = 0;
53535 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53536 int result;
53537 void *argp1 = 0 ;
53538 int res1 = 0 ;
53539 PyObject *swig_obj[1] ;
53540
53541 if (!args) SWIG_fail;
53542 swig_obj[0] = args;
53543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53544 if (!SWIG_IsOK(res1)) {
53545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53546 }
53547 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53548 {
53549 PyThreadState* __tstate = wxPyBeginAllowThreads();
53550 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53551 wxPyEndAllowThreads(__tstate);
53552 if (PyErr_Occurred()) SWIG_fail;
53553 }
53554 resultobj = SWIG_From_int(static_cast< int >(result));
53555 return resultobj;
53556 fail:
53557 return NULL;
53558 }
53559
53560
53561 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53562 PyObject *resultobj = 0;
53563 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53564 bool result;
53565 void *argp1 = 0 ;
53566 int res1 = 0 ;
53567 PyObject *swig_obj[1] ;
53568
53569 if (!args) SWIG_fail;
53570 swig_obj[0] = args;
53571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53572 if (!SWIG_IsOK(res1)) {
53573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53574 }
53575 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53576 {
53577 PyThreadState* __tstate = wxPyBeginAllowThreads();
53578 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53579 wxPyEndAllowThreads(__tstate);
53580 if (PyErr_Occurred()) SWIG_fail;
53581 }
53582 {
53583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53584 }
53585 return resultobj;
53586 fail:
53587 return NULL;
53588 }
53589
53590
53591 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53592 PyObject *resultobj = 0;
53593 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53594 bool arg2 ;
53595 void *argp1 = 0 ;
53596 int res1 = 0 ;
53597 bool val2 ;
53598 int ecode2 = 0 ;
53599 PyObject * obj0 = 0 ;
53600 PyObject * obj1 = 0 ;
53601 char * kwnames[] = {
53602 (char *) "self",(char *) "d", NULL
53603 };
53604
53605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53607 if (!SWIG_IsOK(res1)) {
53608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53609 }
53610 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53611 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53612 if (!SWIG_IsOK(ecode2)) {
53613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53614 }
53615 arg2 = static_cast< bool >(val2);
53616 {
53617 PyThreadState* __tstate = wxPyBeginAllowThreads();
53618 (arg1)->SetDone(arg2);
53619 wxPyEndAllowThreads(__tstate);
53620 if (PyErr_Occurred()) SWIG_fail;
53621 }
53622 resultobj = SWIG_Py_Void();
53623 return resultobj;
53624 fail:
53625 return NULL;
53626 }
53627
53628
53629 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53630 PyObject *resultobj = 0;
53631 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53632 wxRelationship result;
53633 void *argp1 = 0 ;
53634 int res1 = 0 ;
53635 PyObject *swig_obj[1] ;
53636
53637 if (!args) SWIG_fail;
53638 swig_obj[0] = args;
53639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53640 if (!SWIG_IsOK(res1)) {
53641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53642 }
53643 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53644 {
53645 PyThreadState* __tstate = wxPyBeginAllowThreads();
53646 result = (wxRelationship)(arg1)->GetRelationship();
53647 wxPyEndAllowThreads(__tstate);
53648 if (PyErr_Occurred()) SWIG_fail;
53649 }
53650 resultobj = SWIG_From_int(static_cast< int >(result));
53651 return resultobj;
53652 fail:
53653 return NULL;
53654 }
53655
53656
53657 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53658 PyObject *resultobj = 0;
53659 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53660 wxRelationship arg2 ;
53661 void *argp1 = 0 ;
53662 int res1 = 0 ;
53663 int val2 ;
53664 int ecode2 = 0 ;
53665 PyObject * obj0 = 0 ;
53666 PyObject * obj1 = 0 ;
53667 char * kwnames[] = {
53668 (char *) "self",(char *) "r", NULL
53669 };
53670
53671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53673 if (!SWIG_IsOK(res1)) {
53674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53675 }
53676 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53677 ecode2 = SWIG_AsVal_int(obj1, &val2);
53678 if (!SWIG_IsOK(ecode2)) {
53679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53680 }
53681 arg2 = static_cast< wxRelationship >(val2);
53682 {
53683 PyThreadState* __tstate = wxPyBeginAllowThreads();
53684 (arg1)->SetRelationship(arg2);
53685 wxPyEndAllowThreads(__tstate);
53686 if (PyErr_Occurred()) SWIG_fail;
53687 }
53688 resultobj = SWIG_Py_Void();
53689 return resultobj;
53690 fail:
53691 return NULL;
53692 }
53693
53694
53695 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53696 PyObject *resultobj = 0;
53697 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53698 wxWindow *arg2 = (wxWindow *) 0 ;
53699 bool result;
53700 void *argp1 = 0 ;
53701 int res1 = 0 ;
53702 void *argp2 = 0 ;
53703 int res2 = 0 ;
53704 PyObject * obj0 = 0 ;
53705 PyObject * obj1 = 0 ;
53706 char * kwnames[] = {
53707 (char *) "self",(char *) "otherW", NULL
53708 };
53709
53710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53712 if (!SWIG_IsOK(res1)) {
53713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53714 }
53715 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53716 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53717 if (!SWIG_IsOK(res2)) {
53718 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53719 }
53720 arg2 = reinterpret_cast< wxWindow * >(argp2);
53721 {
53722 PyThreadState* __tstate = wxPyBeginAllowThreads();
53723 result = (bool)(arg1)->ResetIfWin(arg2);
53724 wxPyEndAllowThreads(__tstate);
53725 if (PyErr_Occurred()) SWIG_fail;
53726 }
53727 {
53728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53729 }
53730 return resultobj;
53731 fail:
53732 return NULL;
53733 }
53734
53735
53736 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53737 PyObject *resultobj = 0;
53738 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53739 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53740 wxWindow *arg3 = (wxWindow *) 0 ;
53741 bool result;
53742 void *argp1 = 0 ;
53743 int res1 = 0 ;
53744 void *argp2 = 0 ;
53745 int res2 = 0 ;
53746 void *argp3 = 0 ;
53747 int res3 = 0 ;
53748 PyObject * obj0 = 0 ;
53749 PyObject * obj1 = 0 ;
53750 PyObject * obj2 = 0 ;
53751 char * kwnames[] = {
53752 (char *) "self",(char *) "constraints",(char *) "win", NULL
53753 };
53754
53755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53757 if (!SWIG_IsOK(res1)) {
53758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53759 }
53760 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53761 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53762 if (!SWIG_IsOK(res2)) {
53763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53764 }
53765 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53766 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53767 if (!SWIG_IsOK(res3)) {
53768 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53769 }
53770 arg3 = reinterpret_cast< wxWindow * >(argp3);
53771 {
53772 PyThreadState* __tstate = wxPyBeginAllowThreads();
53773 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53774 wxPyEndAllowThreads(__tstate);
53775 if (PyErr_Occurred()) SWIG_fail;
53776 }
53777 {
53778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53779 }
53780 return resultobj;
53781 fail:
53782 return NULL;
53783 }
53784
53785
53786 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53787 PyObject *resultobj = 0;
53788 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53789 wxEdge arg2 ;
53790 wxWindow *arg3 = (wxWindow *) 0 ;
53791 wxWindow *arg4 = (wxWindow *) 0 ;
53792 int result;
53793 void *argp1 = 0 ;
53794 int res1 = 0 ;
53795 int val2 ;
53796 int ecode2 = 0 ;
53797 void *argp3 = 0 ;
53798 int res3 = 0 ;
53799 void *argp4 = 0 ;
53800 int res4 = 0 ;
53801 PyObject * obj0 = 0 ;
53802 PyObject * obj1 = 0 ;
53803 PyObject * obj2 = 0 ;
53804 PyObject * obj3 = 0 ;
53805 char * kwnames[] = {
53806 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53807 };
53808
53809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53811 if (!SWIG_IsOK(res1)) {
53812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53813 }
53814 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53815 ecode2 = SWIG_AsVal_int(obj1, &val2);
53816 if (!SWIG_IsOK(ecode2)) {
53817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53818 }
53819 arg2 = static_cast< wxEdge >(val2);
53820 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53821 if (!SWIG_IsOK(res3)) {
53822 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53823 }
53824 arg3 = reinterpret_cast< wxWindow * >(argp3);
53825 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53826 if (!SWIG_IsOK(res4)) {
53827 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53828 }
53829 arg4 = reinterpret_cast< wxWindow * >(argp4);
53830 {
53831 PyThreadState* __tstate = wxPyBeginAllowThreads();
53832 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53833 wxPyEndAllowThreads(__tstate);
53834 if (PyErr_Occurred()) SWIG_fail;
53835 }
53836 resultobj = SWIG_From_int(static_cast< int >(result));
53837 return resultobj;
53838 fail:
53839 return NULL;
53840 }
53841
53842
53843 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53844 PyObject *obj;
53845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53846 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53847 return SWIG_Py_Void();
53848 }
53849
53850 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53851 PyObject *resultobj = 0;
53852 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53853 wxIndividualLayoutConstraint *result = 0 ;
53854 void *argp1 = 0 ;
53855 int res1 = 0 ;
53856 PyObject *swig_obj[1] ;
53857
53858 if (!args) SWIG_fail;
53859 swig_obj[0] = args;
53860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53861 if (!SWIG_IsOK(res1)) {
53862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53863 }
53864 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53865 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53867 return resultobj;
53868 fail:
53869 return NULL;
53870 }
53871
53872
53873 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53874 PyObject *resultobj = 0;
53875 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53876 wxIndividualLayoutConstraint *result = 0 ;
53877 void *argp1 = 0 ;
53878 int res1 = 0 ;
53879 PyObject *swig_obj[1] ;
53880
53881 if (!args) SWIG_fail;
53882 swig_obj[0] = args;
53883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53884 if (!SWIG_IsOK(res1)) {
53885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53886 }
53887 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53888 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
53889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53890 return resultobj;
53891 fail:
53892 return NULL;
53893 }
53894
53895
53896 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53897 PyObject *resultobj = 0;
53898 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53899 wxIndividualLayoutConstraint *result = 0 ;
53900 void *argp1 = 0 ;
53901 int res1 = 0 ;
53902 PyObject *swig_obj[1] ;
53903
53904 if (!args) SWIG_fail;
53905 swig_obj[0] = args;
53906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53907 if (!SWIG_IsOK(res1)) {
53908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53909 }
53910 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53911 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
53912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53913 return resultobj;
53914 fail:
53915 return NULL;
53916 }
53917
53918
53919 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53920 PyObject *resultobj = 0;
53921 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53922 wxIndividualLayoutConstraint *result = 0 ;
53923 void *argp1 = 0 ;
53924 int res1 = 0 ;
53925 PyObject *swig_obj[1] ;
53926
53927 if (!args) SWIG_fail;
53928 swig_obj[0] = args;
53929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53930 if (!SWIG_IsOK(res1)) {
53931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53932 }
53933 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53934 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
53935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53936 return resultobj;
53937 fail:
53938 return NULL;
53939 }
53940
53941
53942 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53943 PyObject *resultobj = 0;
53944 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53945 wxIndividualLayoutConstraint *result = 0 ;
53946 void *argp1 = 0 ;
53947 int res1 = 0 ;
53948 PyObject *swig_obj[1] ;
53949
53950 if (!args) SWIG_fail;
53951 swig_obj[0] = args;
53952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53953 if (!SWIG_IsOK(res1)) {
53954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53955 }
53956 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53957 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
53958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53959 return resultobj;
53960 fail:
53961 return NULL;
53962 }
53963
53964
53965 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53966 PyObject *resultobj = 0;
53967 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53968 wxIndividualLayoutConstraint *result = 0 ;
53969 void *argp1 = 0 ;
53970 int res1 = 0 ;
53971 PyObject *swig_obj[1] ;
53972
53973 if (!args) SWIG_fail;
53974 swig_obj[0] = args;
53975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53976 if (!SWIG_IsOK(res1)) {
53977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53978 }
53979 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53980 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
53981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53982 return resultobj;
53983 fail:
53984 return NULL;
53985 }
53986
53987
53988 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53989 PyObject *resultobj = 0;
53990 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53991 wxIndividualLayoutConstraint *result = 0 ;
53992 void *argp1 = 0 ;
53993 int res1 = 0 ;
53994 PyObject *swig_obj[1] ;
53995
53996 if (!args) SWIG_fail;
53997 swig_obj[0] = args;
53998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53999 if (!SWIG_IsOK(res1)) {
54000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54001 }
54002 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54003 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
54004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54005 return resultobj;
54006 fail:
54007 return NULL;
54008 }
54009
54010
54011 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54012 PyObject *resultobj = 0;
54013 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54014 wxIndividualLayoutConstraint *result = 0 ;
54015 void *argp1 = 0 ;
54016 int res1 = 0 ;
54017 PyObject *swig_obj[1] ;
54018
54019 if (!args) SWIG_fail;
54020 swig_obj[0] = args;
54021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54022 if (!SWIG_IsOK(res1)) {
54023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54024 }
54025 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54026 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
54027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54028 return resultobj;
54029 fail:
54030 return NULL;
54031 }
54032
54033
54034 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54035 PyObject *resultobj = 0;
54036 wxLayoutConstraints *result = 0 ;
54037
54038 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
54039 {
54040 PyThreadState* __tstate = wxPyBeginAllowThreads();
54041 result = (wxLayoutConstraints *)new wxLayoutConstraints();
54042 wxPyEndAllowThreads(__tstate);
54043 if (PyErr_Occurred()) SWIG_fail;
54044 }
54045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
54046 return resultobj;
54047 fail:
54048 return NULL;
54049 }
54050
54051
54052 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54053 PyObject *resultobj = 0;
54054 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54055 void *argp1 = 0 ;
54056 int res1 = 0 ;
54057 PyObject *swig_obj[1] ;
54058
54059 if (!args) SWIG_fail;
54060 swig_obj[0] = args;
54061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
54062 if (!SWIG_IsOK(res1)) {
54063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54064 }
54065 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54066 {
54067 PyThreadState* __tstate = wxPyBeginAllowThreads();
54068 delete arg1;
54069
54070 wxPyEndAllowThreads(__tstate);
54071 if (PyErr_Occurred()) SWIG_fail;
54072 }
54073 resultobj = SWIG_Py_Void();
54074 return resultobj;
54075 fail:
54076 return NULL;
54077 }
54078
54079
54080 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54081 PyObject *resultobj = 0;
54082 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54083 wxWindow *arg2 = (wxWindow *) 0 ;
54084 int *arg3 = (int *) 0 ;
54085 bool result;
54086 void *argp1 = 0 ;
54087 int res1 = 0 ;
54088 void *argp2 = 0 ;
54089 int res2 = 0 ;
54090 int temp3 ;
54091 int res3 = SWIG_TMPOBJ ;
54092 PyObject * obj0 = 0 ;
54093 PyObject * obj1 = 0 ;
54094 char * kwnames[] = {
54095 (char *) "self",(char *) "win", NULL
54096 };
54097
54098 arg3 = &temp3;
54099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
54100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54101 if (!SWIG_IsOK(res1)) {
54102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54103 }
54104 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54105 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54106 if (!SWIG_IsOK(res2)) {
54107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
54108 }
54109 arg2 = reinterpret_cast< wxWindow * >(argp2);
54110 {
54111 PyThreadState* __tstate = wxPyBeginAllowThreads();
54112 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
54113 wxPyEndAllowThreads(__tstate);
54114 if (PyErr_Occurred()) SWIG_fail;
54115 }
54116 {
54117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54118 }
54119 if (SWIG_IsTmpObj(res3)) {
54120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
54121 } else {
54122 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
54123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
54124 }
54125 return resultobj;
54126 fail:
54127 return NULL;
54128 }
54129
54130
54131 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54132 PyObject *resultobj = 0;
54133 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54134 bool result;
54135 void *argp1 = 0 ;
54136 int res1 = 0 ;
54137 PyObject *swig_obj[1] ;
54138
54139 if (!args) SWIG_fail;
54140 swig_obj[0] = args;
54141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54142 if (!SWIG_IsOK(res1)) {
54143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
54144 }
54145 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54146 {
54147 PyThreadState* __tstate = wxPyBeginAllowThreads();
54148 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
54149 wxPyEndAllowThreads(__tstate);
54150 if (PyErr_Occurred()) SWIG_fail;
54151 }
54152 {
54153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54154 }
54155 return resultobj;
54156 fail:
54157 return NULL;
54158 }
54159
54160
54161 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54162 PyObject *obj;
54163 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54164 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
54165 return SWIG_Py_Void();
54166 }
54167
54168 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54169 return SWIG_Python_InitShadowInstance(args);
54170 }
54171
54172 static PyMethodDef SwigMethods[] = {
54173 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
54174 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
54175 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
54176 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
54177 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
54178 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
54179 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
54180 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
54181 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
54183 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54184 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54187 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54192 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
54196 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
54197 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
54198 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
54200 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
54201 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
54202 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
54203 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
54204 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
54205 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
54206 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
54208 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54210 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54211 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54212 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54213 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
54214 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
54215 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
54216 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
54217 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
54218 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
54219 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
54220 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
54222 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54225 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54226 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54227 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54228 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54229 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
54230 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
54231 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
54232 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
54234 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
54235 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
54236 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
54237 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
54238 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
54239 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
54240 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
54241 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
54242 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54243 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
54244 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54245 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
54246 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54247 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
54248 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54249 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
54250 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
54251 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54252 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
54253 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
54254 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
54255 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
54256 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
54257 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54258 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
54259 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
54260 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
54261 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
54262 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54263 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
54264 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
54265 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
54266 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
54267 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
54268 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
54269 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
54270 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
54271 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
54272 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54273 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54274 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54275 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54276 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
54277 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
54278 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
54279 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54280 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
54281 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
54282 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
54283 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
54284 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
54285 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
54286 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
54287 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
54288 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
54289 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54290 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
54291 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
54292 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
54293 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
54294 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
54295 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
54296 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54297 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
54298 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
54299 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
54300 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
54301 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
54302 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
54303 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
54304 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
54305 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54306 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54307 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
54308 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54309 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54310 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
54311 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
54312 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54313 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54314 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
54315 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
54316 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
54317 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
54318 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54319 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
54320 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
54321 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
54322 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
54323 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
54324 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
54325 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
54326 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
54327 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
54328 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
54329 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
54330 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
54331 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
54332 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
54333 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
54334 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
54335 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
54336 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
54337 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
54339 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
54340 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
54341 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
54342 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
54343 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
54344 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
54345 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
54347 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
54348 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
54349 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
54350 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
54351 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
54352 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
54353 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
54354 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
54355 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
54356 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
54357 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
54358 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54359 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54360 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54361 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54362 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
54363 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
54364 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54365 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54367 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
54369 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
54370 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
54371 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
54372 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
54374 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54375 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54376 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
54377 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54378 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54379 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
54380 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
54382 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
54383 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
54384 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
54385 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54386 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54387 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
54388 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
54389 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
54390 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
54394 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
54395 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
54396 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54398 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
54400 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54401 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54402 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54403 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54404 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
54405 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
54406 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
54407 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
54408 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
54409 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
54410 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
54411 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54412 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54414 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
54415 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
54416 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
54418 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
54419 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54420 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
54421 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
54422 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
54423 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54424 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
54428 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54429 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54430 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54431 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54432 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54433 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54434 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54435 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54436 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54437 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54438 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54439 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54440 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54441 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54442 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54443 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54444 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54445 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54446 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54447 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54448 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54449 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54450 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54454 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54455 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54456 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54457 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54459 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
54461 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
54462 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
54463 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
54464 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
54465 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54466 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54467 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54468 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54469 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54470 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54471 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54472 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54473 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54474 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54475 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54476 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54477 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54478 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54481 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54482 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54483 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54484 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54485 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54490 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54491 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
54492 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54493 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54494 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54495 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54496 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54497 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54498 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54499 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54500 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54501 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54502 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54503 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54504 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54505 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54506 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54508 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54509 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54510 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54511 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54512 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54513 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54514 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54515 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54516 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54517 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54518 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54519 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54520 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54521 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54522 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54523 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54524 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54525 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54526 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54527 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54528 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54529 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54530 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54531 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54532 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54533 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54534 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54535 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54536 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54537 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54538 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54539 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54540 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54541 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54542 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54543 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54544 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54545 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54546 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54547 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54548 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54549 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54550 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54551 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54552 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54553 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54554 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54555 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54556 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54557 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54558 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54559 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54560 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54561 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54562 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54563 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54564 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54565 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54566 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54567 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54568 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54569 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54570 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54571 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54572 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54573 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54574 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54575 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54576 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54577 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54578 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54579 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54580 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54581 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54582 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54583 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54584 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54585 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54586 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54587 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54588 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54589 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54590 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54591 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54592 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54593 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54594 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54595 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54596 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54597 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54598 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54599 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54600 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54601 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54603 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54604 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54605 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54606 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54607 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54608 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54609 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54610 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54611 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54612 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54613 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54614 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54615 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54616 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54617 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54618 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54619 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54620 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54621 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54622 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54623 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54624 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54625 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54626 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54627 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54629 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54630 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54631 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54632 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54633 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54634 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54635 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54636 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54637 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54638 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54639 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54640 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54641 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54642 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54643 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54644 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54645 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54646 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54647 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54648 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54649 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54650 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54651 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54652 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54653 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54654 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54655 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54656 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54657 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54658 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54659 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54660 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54661 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54662 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54663 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54664 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54665 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54666 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54667 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54668 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54669 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54670 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54671 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54672 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54673 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54674 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54675 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54676 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54677 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54678 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54679 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54680 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54681 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54682 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54683 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54684 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54685 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54686 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54687 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54688 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54689 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54690 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54691 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54692 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54693 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54694 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54695 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54696 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54697 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54698 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54699 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54700 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54701 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54702 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54703 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54704 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54705 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54706 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54707 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54708 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54709 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54710 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54711 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54712 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54713 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54714 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54715 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54716 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54717 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54718 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54719 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54720 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54721 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54722 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54723 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54724 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54725 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54726 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54727 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54728 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54729 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54730 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54731 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54732 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54733 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54734 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54735 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54736 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54737 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54738 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54739 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54740 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54741 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54742 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54743 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54744 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54745 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54746 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54747 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54748 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54749 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54750 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54751 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54752 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54753 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54754 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54755 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54756 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54757 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54758 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54759 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54760 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54761 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54762 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54763 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54764 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54765 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54767 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54768 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54769 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54770 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54771 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54772 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54773 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54774 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54775 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54776 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54777 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54778 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54779 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54780 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54781 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54782 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54783 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54784 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54785 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54786 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54787 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54788 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54789 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54790 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54791 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54792 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54793 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54794 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54795 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54796 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54797 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54798 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54799 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54800 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54801 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54802 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54803 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54804 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54805 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54806 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54807 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54808 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54809 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54810 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54811 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54812 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54813 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54814 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54815 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54816 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54817 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54818 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54819 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54820 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54821 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54822 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54823 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54824 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54825 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54826 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54827 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54828 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54829 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54830 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54831 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54832 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54833 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54834 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54835 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54836 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54837 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54838 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54839 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54840 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54841 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54842 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54843 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54844 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54845 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54846 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54847 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54848 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54849 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54850 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54851 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54852 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54853 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54854 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54855 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54856 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54857 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54858 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54859 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54860 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54861 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54862 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54863 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54864 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54865 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54866 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54867 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54868 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54869 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54870 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54871 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54872 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54873 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54874 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54875 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54876 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54877 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54878 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54879 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54880 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54881 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54882 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
54883 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54884 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
54885 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
54886 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
54887 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
54888 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
54889 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
54890 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
54891 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
54892 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
54893 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54894 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
54895 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
54896 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
54897 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54898 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
54899 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
54900 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
54901 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54902 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
54903 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54904 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
54905 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
54906 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
54907 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
54908 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
54909 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54910 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
54911 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
54912 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
54913 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
54914 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54915 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
54916 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
54917 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54918 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
54919 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54920 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
54921 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
54922 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
54923 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54924 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
54925 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54926 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
54927 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
54928 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
54929 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54930 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
54931 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
54932 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
54933 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
54934 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
54935 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
54936 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54937 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
54938 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
54939 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
54940 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
54941 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
54942 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
54943 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
54944 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
54945 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
54946 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
54947 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
54948 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
54949 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
54950 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
54951 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
54952 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
54953 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
54954 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
54955 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
54956 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
54957 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54958 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
54959 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
54960 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
54961 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
54962 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
54963 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
54964 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
54965 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
54966 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
54967 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
54968 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
54969 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
54970 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
54971 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
54972 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
54973 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54974 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54975 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54976 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
54977 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
54978 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
54979 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
54980 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
54981 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
54982 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
54983 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
54984 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
54985 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
54986 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
54987 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54988 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
54989 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
54990 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
54991 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
54992 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
54993 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
54994 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
54995 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
54996 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
54997 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
54998 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
54999 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
55000 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
55001 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
55002 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
55003 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
55004 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
55005 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
55006 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
55007 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
55008 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
55009 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55010 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55011 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
55012 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
55013 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
55014 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
55015 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
55016 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
55017 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
55018 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
55019 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55020 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
55021 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
55022 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
55023 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
55024 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
55025 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
55026 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
55027 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
55028 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
55029 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
55030 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
55031 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
55032 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
55033 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
55034 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
55035 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
55036 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
55037 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55038 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
55039 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
55040 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
55041 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
55042 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55043 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
55044 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
55045 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
55046 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
55047 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
55048 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55049 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
55050 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
55051 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55052 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55053 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
55054 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55055 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55056 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
55057 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
55058 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
55059 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55060 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
55061 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
55062 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
55063 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
55064 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
55065 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
55066 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55067 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
55068 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
55069 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
55070 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
55071 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
55072 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
55073 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
55074 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
55075 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
55076 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
55077 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
55078 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
55079 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
55080 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
55081 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
55082 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
55083 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
55084 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
55085 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
55086 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
55087 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
55088 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
55089 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
55090 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55091 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55092 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55093 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55094 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
55095 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
55096 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55097 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
55098 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
55099 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
55100 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
55101 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
55102 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
55103 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55104 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
55105 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
55106 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
55107 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55108 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
55109 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55110 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
55111 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
55112 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
55113 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
55114 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55115 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
55116 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55117 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
55118 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55119 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
55120 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
55121 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55122 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
55123 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
55124 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
55125 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
55126 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
55127 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
55128 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
55129 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55130 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55131 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
55132 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
55133 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
55134 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
55135 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
55136 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
55137 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
55138 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
55139 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55140 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55141 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
55142 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55143 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55144 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55145 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55146 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
55147 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
55148 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
55149 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
55150 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
55151 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
55152 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55153 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
55154 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55155 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55156 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55157 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55158 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
55159 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
55160 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55161 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55162 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
55163 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
55164 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
55165 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
55166 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
55167 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
55168 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
55169 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
55170 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
55171 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
55172 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
55173 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
55174 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
55175 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
55176 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
55177 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
55178 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55179 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
55180 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
55181 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55182 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55183 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55184 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55185 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55186 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
55187 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
55188 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
55189 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
55190 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55191 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
55192 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
55193 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
55194 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
55195 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55196 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
55197 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
55198 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
55199 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
55200 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
55201 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
55202 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55203 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55204 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
55205 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
55206 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
55207 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
55208 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
55209 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
55210 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
55211 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
55212 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
55213 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55214 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
55215 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
55216 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
55217 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
55218 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
55219 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55220 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55221 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55222 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55223 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
55224 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
55225 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55226 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
55227 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
55228 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
55229 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
55230 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
55231 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
55232 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
55233 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
55234 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55235 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
55236 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
55237 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
55238 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
55239 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
55240 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
55241 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
55242 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55243 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
55244 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
55245 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
55246 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
55247 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55248 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
55249 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
55250 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55251 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
55252 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
55253 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
55254 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
55255 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
55256 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
55257 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
55258 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55259 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55260 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55261 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
55262 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
55263 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
55264 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
55265 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
55266 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
55267 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
55268 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
55269 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55270 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
55271 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
55272 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
55273 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
55274 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
55275 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55276 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
55277 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
55278 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
55279 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55280 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
55281 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55282 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55283 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55284 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55285 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
55286 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55287 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55288 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
55289 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55290 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
55291 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55292 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55293 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55294 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55295 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
55296 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55297 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55298 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55299 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55300 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
55301 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55302 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
55303 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
55304 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
55305 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
55306 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
55307 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
55308 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
55309 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55310 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55311 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55312 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55313 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55314 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55315 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55316 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55317 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55318 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55319 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
55320 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
55321 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55322 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
55323 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55324 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
55325 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
55326 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
55327 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
55328 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55329 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
55330 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
55331 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
55332 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
55333 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
55334 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
55335 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
55336 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55337 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55338 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
55339 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55340 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
55341 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55342 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
55343 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
55344 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55345 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55346 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55347 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55348 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55349 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55350 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55351 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55352 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55353 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55354 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55355 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55356 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55357 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
55358 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
55359 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55360 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
55361 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
55362 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55363 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
55364 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
55365 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
55366 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55367 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
55368 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
55369 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55370 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55371 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
55372 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
55373 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
55374 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
55375 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
55376 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
55377 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
55378 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
55379 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
55380 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
55381 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
55382 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55383 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
55384 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55385 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
55386 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55387 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
55388 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
55389 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
55390 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
55391 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
55392 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
55393 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55394 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
55395 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55396 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
55397 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
55398 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
55399 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55400 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
55401 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
55402 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55403 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
55404 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
55405 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
55406 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
55407 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
55408 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
55409 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
55410 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
55411 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
55412 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
55413 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
55414 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55415 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
55416 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
55417 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
55418 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55419 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
55420 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
55421 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55422 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
55423 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55424 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
55425 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55426 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55427 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55428 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
55429 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
55430 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
55431 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
55432 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55433 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55434 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55435 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55436 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55437 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55438 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55439 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55440 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55441 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55442 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55443 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55444 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55445 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55446 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55447 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55448 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55449 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55450 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55451 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55452 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55453 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55454 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55455 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55456 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55457 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55458 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55459 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55460 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55461 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55462 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55463 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55464 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55465 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55466 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55467 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55468 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55469 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55470 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55471 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55472 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55473 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55474 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55475 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55476 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55477 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55478 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55479 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55480 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55481 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55482 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55483 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55484 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55485 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55486 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55487 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55488 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55489 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55490 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55491 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55492 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55493 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55494 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55495 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55496 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55497 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55498 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55499 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55500 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55501 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55502 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55503 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55504 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55505 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55506 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55507 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55508 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55509 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55510 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55511 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55512 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55513 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55514 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55515 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55516 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55517 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55518 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55519 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55520 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55521 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55522 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55523 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55524 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55525 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55526 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55527 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55528 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55529 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55530 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55531 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55532 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55533 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55534 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55535 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55536 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55537 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55538 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55539 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55540 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55541 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55542 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55543 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55544 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55545 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55546 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55547 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55548 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55549 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55550 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55551 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55552 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55553 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55554 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55555 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55556 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55557 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55558 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55559 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55560 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55561 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55562 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55563 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55564 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55565 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55566 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55567 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55568 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55569 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55570 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55571 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55572 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55573 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55574 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55575 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55576 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55577 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55578 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55579 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55580 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55581 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55582 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55583 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55584 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55585 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55586 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55587 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55588 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55589 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55590 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55591 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55592 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55593 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55594 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55595 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55596 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55597 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55598 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55599 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55600 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55601 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55602 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55603 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55604 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55605 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55606 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55607 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55608 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55609 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55610 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55611 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55612 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55613 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55614 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55615 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55616 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55617 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55618 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55619 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55620 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55621 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55622 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55623 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55624 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55625 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55626 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55627 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55628 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55629 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55630 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55631 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55632 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55633 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55634 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55635 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55636 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55637 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55638 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55639 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55640 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55641 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55642 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55643 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55644 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55645 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55646 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55647 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55648 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55649 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55650 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55651 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55652 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55653 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55654 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55655 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55656 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55657 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55658 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55659 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55660 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55661 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55662 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55663 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55664 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55665 { NULL, NULL, 0, NULL }
55666 };
55667
55668
55669 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55670
55671 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55672 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55673 }
55674 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55675 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55676 }
55677 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55678 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55679 }
55680 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55681 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55682 }
55683 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55684 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55685 }
55686 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55687 return (void *)((wxSizer *) ((wxGridSizer *) x));
55688 }
55689 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55690 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55691 }
55692 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55693 return (void *)((wxSizer *) ((wxPySizer *) x));
55694 }
55695 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55696 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55697 }
55698 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55699 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55700 }
55701 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55702 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55703 }
55704 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55705 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55706 }
55707 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55708 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55709 }
55710 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55711 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55712 }
55713 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55714 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55715 }
55716 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55717 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55718 }
55719 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55720 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55721 }
55722 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55723 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55724 }
55725 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55726 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55727 }
55728 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55729 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55730 }
55731 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55732 return (void *)((wxEvent *) ((wxPyEvent *) x));
55733 }
55734 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55735 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55736 }
55737 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55738 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55739 }
55740 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55741 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55742 }
55743 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55744 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55745 }
55746 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55747 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55748 }
55749 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55750 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55751 }
55752 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55753 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55754 }
55755 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55756 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55757 }
55758 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55759 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55760 }
55761 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55762 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55763 }
55764 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55765 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55766 }
55767 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55768 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55769 }
55770 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55771 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55772 }
55773 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55774 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55775 }
55776 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55777 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55778 }
55779 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55780 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55781 }
55782 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55783 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55784 }
55785 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55786 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55787 }
55788 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55789 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55790 }
55791 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55792 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55793 }
55794 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55795 return (void *)((wxEvent *) ((wxShowEvent *) x));
55796 }
55797 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55798 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55799 }
55800 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55801 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55802 }
55803 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55804 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55805 }
55806 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55807 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55808 }
55809 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55810 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55811 }
55812 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55813 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55814 }
55815 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55816 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55817 }
55818 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55819 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55820 }
55821 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55822 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55823 }
55824 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55825 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55826 }
55827 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55828 return (void *)((wxControl *) ((wxControlWithItems *) x));
55829 }
55830 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55831 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55832 }
55833 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55834 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55835 }
55836 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55837 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55838 }
55839 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55840 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55841 }
55842 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55843 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55844 }
55845 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55846 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55847 }
55848 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55849 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55850 }
55851 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55852 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55853 }
55854 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55855 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55856 }
55857 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55858 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55859 }
55860 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55861 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55862 }
55863 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55864 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55865 }
55866 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55867 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55868 }
55869 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55870 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55871 }
55872 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55873 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55874 }
55875 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55876 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55877 }
55878 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55879 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55880 }
55881 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55882 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55883 }
55884 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
55885 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55886 }
55887 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
55888 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
55889 }
55890 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
55891 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
55892 }
55893 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
55894 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
55895 }
55896 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
55897 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
55898 }
55899 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
55900 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
55901 }
55902 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
55903 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
55904 }
55905 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
55906 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
55907 }
55908 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
55909 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
55910 }
55911 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
55912 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
55913 }
55914 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
55915 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
55916 }
55917 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
55918 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
55919 }
55920 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
55921 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
55922 }
55923 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
55924 return (void *)((wxObject *) ((wxSizerItem *) x));
55925 }
55926 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
55927 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
55928 }
55929 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
55930 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
55931 }
55932 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
55933 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
55934 }
55935 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
55936 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
55937 }
55938 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
55939 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
55940 }
55941 static void *_p_wxSizerTo_p_wxObject(void *x) {
55942 return (void *)((wxObject *) ((wxSizer *) x));
55943 }
55944 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
55945 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55946 }
55947 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
55948 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
55949 }
55950 static void *_p_wxEventTo_p_wxObject(void *x) {
55951 return (void *)((wxObject *) ((wxEvent *) x));
55952 }
55953 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
55954 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
55955 }
55956 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
55957 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
55958 }
55959 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
55960 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
55961 }
55962 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
55963 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
55964 }
55965 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
55966 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
55967 }
55968 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
55969 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
55970 }
55971 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
55972 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
55973 }
55974 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
55975 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
55976 }
55977 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
55978 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55979 }
55980 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
55981 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
55982 }
55983 static void *_p_wxControlTo_p_wxObject(void *x) {
55984 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
55985 }
55986 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
55987 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
55988 }
55989 static void *_p_wxFSFileTo_p_wxObject(void *x) {
55990 return (void *)((wxObject *) ((wxFSFile *) x));
55991 }
55992 static void *_p_wxPySizerTo_p_wxObject(void *x) {
55993 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
55994 }
55995 static void *_p_wxPyEventTo_p_wxObject(void *x) {
55996 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
55997 }
55998 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
55999 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
56000 }
56001 static void *_p_wxShowEventTo_p_wxObject(void *x) {
56002 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
56003 }
56004 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
56005 return (void *)((wxObject *) ((wxMenuItem *) x));
56006 }
56007 static void *_p_wxDateEventTo_p_wxObject(void *x) {
56008 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
56009 }
56010 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
56011 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
56012 }
56013 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
56014 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
56015 }
56016 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
56017 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
56018 }
56019 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
56020 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
56021 }
56022 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
56023 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
56024 }
56025 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
56026 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
56027 }
56028 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
56029 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
56030 }
56031 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
56032 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
56033 }
56034 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
56035 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
56036 }
56037 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
56038 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
56039 }
56040 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
56041 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
56042 }
56043 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
56044 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
56045 }
56046 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
56047 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
56048 }
56049 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
56050 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56051 }
56052 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
56053 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56054 }
56055 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
56056 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
56057 }
56058 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
56059 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
56060 }
56061 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
56062 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
56063 }
56064 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
56065 return (void *)((wxObject *) ((wxImageHandler *) x));
56066 }
56067 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
56068 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
56069 }
56070 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
56071 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
56072 }
56073 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
56074 return (void *)((wxObject *) ((wxEvtHandler *) x));
56075 }
56076 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
56077 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
56078 }
56079 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
56080 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
56081 }
56082 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
56083 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
56084 }
56085 static void *_p_wxImageTo_p_wxObject(void *x) {
56086 return (void *)((wxObject *) ((wxImage *) x));
56087 }
56088 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
56089 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
56090 }
56091 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
56092 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56093 }
56094 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
56095 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
56096 }
56097 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
56098 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
56099 }
56100 static void *_p_wxWindowTo_p_wxObject(void *x) {
56101 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
56102 }
56103 static void *_p_wxMenuTo_p_wxObject(void *x) {
56104 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
56105 }
56106 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
56107 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
56108 }
56109 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
56110 return (void *)((wxObject *) ((wxFileSystem *) x));
56111 }
56112 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
56113 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
56114 }
56115 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
56116 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
56117 }
56118 static void *_p_wxPyAppTo_p_wxObject(void *x) {
56119 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
56120 }
56121 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
56122 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
56123 }
56124 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
56125 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
56126 }
56127 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
56128 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
56129 }
56130 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
56131 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
56132 }
56133 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
56134 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
56135 }
56136 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
56137 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
56138 }
56139 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
56140 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
56141 }
56142 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
56143 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
56144 }
56145 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
56146 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
56147 }
56148 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
56149 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
56150 }
56151 static void *_p_wxValidatorTo_p_wxObject(void *x) {
56152 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
56153 }
56154 static void *_p_wxControlTo_p_wxWindow(void *x) {
56155 return (void *)((wxWindow *) ((wxControl *) x));
56156 }
56157 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
56158 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
56159 }
56160 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
56161 return (void *)((wxWindow *) ((wxMenuBar *) x));
56162 }
56163 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
56164 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
56165 }
56166 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
56167 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
56168 }
56169 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
56170 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
56171 }
56172 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
56173 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
56174 }
56175 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
56176 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
56177 }
56178 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
56179 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
56180 }
56181 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
56182 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56183 }
56184 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
56185 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
56186 }
56187 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
56188 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
56189 }
56190 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
56191 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
56192 }
56193 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
56194 return (void *)((wxValidator *) ((wxPyValidator *) x));
56195 }
56196 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
56197 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
56198 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};
56199 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
56200 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
56201 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
56202 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
56203 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
56204 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
56205 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
56206 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
56207 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
56208 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
56209 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
56210 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
56211 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
56212 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
56213 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
56214 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
56215 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
56216 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
56217 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
56218 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
56219 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
56220 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
56221 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
56222 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
56223 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
56224 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
56225 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
56226 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
56227 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
56228 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
56229 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
56230 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
56231 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
56232 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
56233 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
56234 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
56235 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
56236 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
56237 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
56238 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
56239 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
56240 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
56241 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
56242 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
56243 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
56244 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
56245 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
56246 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
56247 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
56248 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
56249 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
56250 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
56251 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
56252 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
56253 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
56254 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
56255 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
56256 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
56257 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
56258 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
56259 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
56260 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
56261 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
56262 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
56263 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
56264 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
56265 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
56266 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
56267 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
56268 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
56269 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
56270 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
56271 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
56272 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
56273 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
56274 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
56275 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
56276 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
56277 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
56278 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
56279 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
56280 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
56281 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
56282 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
56283 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
56284 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
56285 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
56286 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
56287 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
56288 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
56289 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
56290 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
56291 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
56292 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
56293 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
56294 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
56295 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
56296 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
56297 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
56298 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
56299 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
56300 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
56301 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
56302 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
56303 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
56304 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
56305 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
56306 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
56307 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
56308 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
56309 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
56310 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
56311 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
56312 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
56313 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
56314 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
56315 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
56316 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
56317 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
56318 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
56319 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
56320 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
56321 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
56322 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
56323 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
56324 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
56325 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
56326 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
56327 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
56328
56329 static swig_type_info *swig_type_initial[] = {
56330 &_swigt__p_buffer,
56331 &_swigt__p_char,
56332 &_swigt__p_form_ops_t,
56333 &_swigt__p_int,
56334 &_swigt__p_long,
56335 &_swigt__p_unsigned_char,
56336 &_swigt__p_unsigned_int,
56337 &_swigt__p_unsigned_long,
56338 &_swigt__p_wxANIHandler,
56339 &_swigt__p_wxAcceleratorEntry,
56340 &_swigt__p_wxAcceleratorTable,
56341 &_swigt__p_wxActivateEvent,
56342 &_swigt__p_wxAppTraits,
56343 &_swigt__p_wxArrayString,
56344 &_swigt__p_wxBMPHandler,
56345 &_swigt__p_wxBitmap,
56346 &_swigt__p_wxBoxSizer,
56347 &_swigt__p_wxButton,
56348 &_swigt__p_wxCURHandler,
56349 &_swigt__p_wxCaret,
56350 &_swigt__p_wxChildFocusEvent,
56351 &_swigt__p_wxClipboardTextEvent,
56352 &_swigt__p_wxCloseEvent,
56353 &_swigt__p_wxColour,
56354 &_swigt__p_wxCommandEvent,
56355 &_swigt__p_wxContextMenuEvent,
56356 &_swigt__p_wxControl,
56357 &_swigt__p_wxControlWithItems,
56358 &_swigt__p_wxCursor,
56359 &_swigt__p_wxDC,
56360 &_swigt__p_wxDateEvent,
56361 &_swigt__p_wxDateTime,
56362 &_swigt__p_wxDisplayChangedEvent,
56363 &_swigt__p_wxDropFilesEvent,
56364 &_swigt__p_wxDuplexMode,
56365 &_swigt__p_wxEraseEvent,
56366 &_swigt__p_wxEvent,
56367 &_swigt__p_wxEventLoop,
56368 &_swigt__p_wxEventLoopActivator,
56369 &_swigt__p_wxEvtHandler,
56370 &_swigt__p_wxFSFile,
56371 &_swigt__p_wxFileSystem,
56372 &_swigt__p_wxFileSystemHandler,
56373 &_swigt__p_wxFlexGridSizer,
56374 &_swigt__p_wxFocusEvent,
56375 &_swigt__p_wxFont,
56376 &_swigt__p_wxFrame,
56377 &_swigt__p_wxGBPosition,
56378 &_swigt__p_wxGBSizerItem,
56379 &_swigt__p_wxGBSpan,
56380 &_swigt__p_wxGIFHandler,
56381 &_swigt__p_wxGridBagSizer,
56382 &_swigt__p_wxGridSizer,
56383 &_swigt__p_wxHelpEvent__Origin,
56384 &_swigt__p_wxICOHandler,
56385 &_swigt__p_wxIconizeEvent,
56386 &_swigt__p_wxIdleEvent,
56387 &_swigt__p_wxImage,
56388 &_swigt__p_wxImageHandler,
56389 &_swigt__p_wxImageHistogram,
56390 &_swigt__p_wxImage_HSVValue,
56391 &_swigt__p_wxImage_RGBValue,
56392 &_swigt__p_wxIndividualLayoutConstraint,
56393 &_swigt__p_wxInitDialogEvent,
56394 &_swigt__p_wxInputStream,
56395 &_swigt__p_wxInternetFSHandler,
56396 &_swigt__p_wxItemContainer,
56397 &_swigt__p_wxJPEGHandler,
56398 &_swigt__p_wxKeyEvent,
56399 &_swigt__p_wxLayoutConstraints,
56400 &_swigt__p_wxMaximizeEvent,
56401 &_swigt__p_wxMemoryFSHandler,
56402 &_swigt__p_wxMenu,
56403 &_swigt__p_wxMenuBar,
56404 &_swigt__p_wxMenuBarBase,
56405 &_swigt__p_wxMenuEvent,
56406 &_swigt__p_wxMenuItem,
56407 &_swigt__p_wxMouseCaptureChangedEvent,
56408 &_swigt__p_wxMouseCaptureLostEvent,
56409 &_swigt__p_wxMouseEvent,
56410 &_swigt__p_wxMoveEvent,
56411 &_swigt__p_wxNavigationKeyEvent,
56412 &_swigt__p_wxNcPaintEvent,
56413 &_swigt__p_wxNotifyEvent,
56414 &_swigt__p_wxObject,
56415 &_swigt__p_wxOutputStream,
56416 &_swigt__p_wxPCXHandler,
56417 &_swigt__p_wxPNGHandler,
56418 &_swigt__p_wxPNMHandler,
56419 &_swigt__p_wxPaintEvent,
56420 &_swigt__p_wxPaletteChangedEvent,
56421 &_swigt__p_wxPaperSize,
56422 &_swigt__p_wxPoint,
56423 &_swigt__p_wxPoint2D,
56424 &_swigt__p_wxPropagateOnce,
56425 &_swigt__p_wxPropagationDisabler,
56426 &_swigt__p_wxPyApp,
56427 &_swigt__p_wxPyCommandEvent,
56428 &_swigt__p_wxPyDropTarget,
56429 &_swigt__p_wxPyEvent,
56430 &_swigt__p_wxPyFileSystemHandler,
56431 &_swigt__p_wxPyImageHandler,
56432 &_swigt__p_wxPyInputStream,
56433 &_swigt__p_wxPySizer,
56434 &_swigt__p_wxPyValidator,
56435 &_swigt__p_wxQuantize,
56436 &_swigt__p_wxQueryNewPaletteEvent,
56437 &_swigt__p_wxRealPoint,
56438 &_swigt__p_wxRect,
56439 &_swigt__p_wxRegion,
56440 &_swigt__p_wxScrollEvent,
56441 &_swigt__p_wxScrollWinEvent,
56442 &_swigt__p_wxSetCursorEvent,
56443 &_swigt__p_wxShowEvent,
56444 &_swigt__p_wxSize,
56445 &_swigt__p_wxSizeEvent,
56446 &_swigt__p_wxSizer,
56447 &_swigt__p_wxSizerItem,
56448 &_swigt__p_wxStaticBox,
56449 &_swigt__p_wxStaticBoxSizer,
56450 &_swigt__p_wxStdDialogButtonSizer,
56451 &_swigt__p_wxSysColourChangedEvent,
56452 &_swigt__p_wxTIFFHandler,
56453 &_swigt__p_wxToolTip,
56454 &_swigt__p_wxUpdateUIEvent,
56455 &_swigt__p_wxValidator,
56456 &_swigt__p_wxVisualAttributes,
56457 &_swigt__p_wxWindow,
56458 &_swigt__p_wxWindowCreateEvent,
56459 &_swigt__p_wxWindowDestroyEvent,
56460 &_swigt__p_wxXPMHandler,
56461 &_swigt__p_wxZipFSHandler,
56462 };
56463
56464 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56465 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56466 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56467 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56468 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56469 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56470 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56471 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56472 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56473 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56474 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56475 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56476 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56477 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56478 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}};
56479 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56480 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}};
56481 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56482 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}};
56483 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56484 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56485 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56486 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56487 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56488 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}};
56489 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56490 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}};
56491 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56492 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56493 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56494 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56495 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56496 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56497 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56498 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56499 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56500 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}};
56501 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56502 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56503 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}};
56504 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56505 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56506 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}};
56507 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}};
56508 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56509 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56510 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56511 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56512 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56513 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56514 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56515 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56516 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}};
56517 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56518 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}};
56519 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56520 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56521 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56522 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}};
56523 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56524 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56525 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56526 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56527 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56528 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56529 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56530 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}};
56531 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56532 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56533 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56534 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56535 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56536 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56537 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56538 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56539 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56540 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56541 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56542 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56543 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56544 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56545 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56546 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56547 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56548 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}};
56549 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56550 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56551 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56552 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56553 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56554 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56555 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56556 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56557 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56558 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56559 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56560 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56561 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56562 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56563 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56564 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56565 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56566 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56567 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56568 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56569 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56570 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56571 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56572 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56573 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56574 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56575 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56576 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56577 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56578 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56579 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56580 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}};
56581 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}};
56582 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56583 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56584 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56585 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56586 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56587 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56588 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56589 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}};
56590 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56591 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}};
56592 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56593 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56594 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56595 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56596
56597 static swig_cast_info *swig_cast_initial[] = {
56598 _swigc__p_buffer,
56599 _swigc__p_char,
56600 _swigc__p_form_ops_t,
56601 _swigc__p_int,
56602 _swigc__p_long,
56603 _swigc__p_unsigned_char,
56604 _swigc__p_unsigned_int,
56605 _swigc__p_unsigned_long,
56606 _swigc__p_wxANIHandler,
56607 _swigc__p_wxAcceleratorEntry,
56608 _swigc__p_wxAcceleratorTable,
56609 _swigc__p_wxActivateEvent,
56610 _swigc__p_wxAppTraits,
56611 _swigc__p_wxArrayString,
56612 _swigc__p_wxBMPHandler,
56613 _swigc__p_wxBitmap,
56614 _swigc__p_wxBoxSizer,
56615 _swigc__p_wxButton,
56616 _swigc__p_wxCURHandler,
56617 _swigc__p_wxCaret,
56618 _swigc__p_wxChildFocusEvent,
56619 _swigc__p_wxClipboardTextEvent,
56620 _swigc__p_wxCloseEvent,
56621 _swigc__p_wxColour,
56622 _swigc__p_wxCommandEvent,
56623 _swigc__p_wxContextMenuEvent,
56624 _swigc__p_wxControl,
56625 _swigc__p_wxControlWithItems,
56626 _swigc__p_wxCursor,
56627 _swigc__p_wxDC,
56628 _swigc__p_wxDateEvent,
56629 _swigc__p_wxDateTime,
56630 _swigc__p_wxDisplayChangedEvent,
56631 _swigc__p_wxDropFilesEvent,
56632 _swigc__p_wxDuplexMode,
56633 _swigc__p_wxEraseEvent,
56634 _swigc__p_wxEvent,
56635 _swigc__p_wxEventLoop,
56636 _swigc__p_wxEventLoopActivator,
56637 _swigc__p_wxEvtHandler,
56638 _swigc__p_wxFSFile,
56639 _swigc__p_wxFileSystem,
56640 _swigc__p_wxFileSystemHandler,
56641 _swigc__p_wxFlexGridSizer,
56642 _swigc__p_wxFocusEvent,
56643 _swigc__p_wxFont,
56644 _swigc__p_wxFrame,
56645 _swigc__p_wxGBPosition,
56646 _swigc__p_wxGBSizerItem,
56647 _swigc__p_wxGBSpan,
56648 _swigc__p_wxGIFHandler,
56649 _swigc__p_wxGridBagSizer,
56650 _swigc__p_wxGridSizer,
56651 _swigc__p_wxHelpEvent__Origin,
56652 _swigc__p_wxICOHandler,
56653 _swigc__p_wxIconizeEvent,
56654 _swigc__p_wxIdleEvent,
56655 _swigc__p_wxImage,
56656 _swigc__p_wxImageHandler,
56657 _swigc__p_wxImageHistogram,
56658 _swigc__p_wxImage_HSVValue,
56659 _swigc__p_wxImage_RGBValue,
56660 _swigc__p_wxIndividualLayoutConstraint,
56661 _swigc__p_wxInitDialogEvent,
56662 _swigc__p_wxInputStream,
56663 _swigc__p_wxInternetFSHandler,
56664 _swigc__p_wxItemContainer,
56665 _swigc__p_wxJPEGHandler,
56666 _swigc__p_wxKeyEvent,
56667 _swigc__p_wxLayoutConstraints,
56668 _swigc__p_wxMaximizeEvent,
56669 _swigc__p_wxMemoryFSHandler,
56670 _swigc__p_wxMenu,
56671 _swigc__p_wxMenuBar,
56672 _swigc__p_wxMenuBarBase,
56673 _swigc__p_wxMenuEvent,
56674 _swigc__p_wxMenuItem,
56675 _swigc__p_wxMouseCaptureChangedEvent,
56676 _swigc__p_wxMouseCaptureLostEvent,
56677 _swigc__p_wxMouseEvent,
56678 _swigc__p_wxMoveEvent,
56679 _swigc__p_wxNavigationKeyEvent,
56680 _swigc__p_wxNcPaintEvent,
56681 _swigc__p_wxNotifyEvent,
56682 _swigc__p_wxObject,
56683 _swigc__p_wxOutputStream,
56684 _swigc__p_wxPCXHandler,
56685 _swigc__p_wxPNGHandler,
56686 _swigc__p_wxPNMHandler,
56687 _swigc__p_wxPaintEvent,
56688 _swigc__p_wxPaletteChangedEvent,
56689 _swigc__p_wxPaperSize,
56690 _swigc__p_wxPoint,
56691 _swigc__p_wxPoint2D,
56692 _swigc__p_wxPropagateOnce,
56693 _swigc__p_wxPropagationDisabler,
56694 _swigc__p_wxPyApp,
56695 _swigc__p_wxPyCommandEvent,
56696 _swigc__p_wxPyDropTarget,
56697 _swigc__p_wxPyEvent,
56698 _swigc__p_wxPyFileSystemHandler,
56699 _swigc__p_wxPyImageHandler,
56700 _swigc__p_wxPyInputStream,
56701 _swigc__p_wxPySizer,
56702 _swigc__p_wxPyValidator,
56703 _swigc__p_wxQuantize,
56704 _swigc__p_wxQueryNewPaletteEvent,
56705 _swigc__p_wxRealPoint,
56706 _swigc__p_wxRect,
56707 _swigc__p_wxRegion,
56708 _swigc__p_wxScrollEvent,
56709 _swigc__p_wxScrollWinEvent,
56710 _swigc__p_wxSetCursorEvent,
56711 _swigc__p_wxShowEvent,
56712 _swigc__p_wxSize,
56713 _swigc__p_wxSizeEvent,
56714 _swigc__p_wxSizer,
56715 _swigc__p_wxSizerItem,
56716 _swigc__p_wxStaticBox,
56717 _swigc__p_wxStaticBoxSizer,
56718 _swigc__p_wxStdDialogButtonSizer,
56719 _swigc__p_wxSysColourChangedEvent,
56720 _swigc__p_wxTIFFHandler,
56721 _swigc__p_wxToolTip,
56722 _swigc__p_wxUpdateUIEvent,
56723 _swigc__p_wxValidator,
56724 _swigc__p_wxVisualAttributes,
56725 _swigc__p_wxWindow,
56726 _swigc__p_wxWindowCreateEvent,
56727 _swigc__p_wxWindowDestroyEvent,
56728 _swigc__p_wxXPMHandler,
56729 _swigc__p_wxZipFSHandler,
56730 };
56731
56732
56733 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56734
56735 static swig_const_info swig_const_table[] = {
56736 {0, 0, 0, 0.0, 0, 0}};
56737
56738 #ifdef __cplusplus
56739 }
56740 #endif
56741 /* -----------------------------------------------------------------------------
56742 * Type initialization:
56743 * This problem is tough by the requirement that no dynamic
56744 * memory is used. Also, since swig_type_info structures store pointers to
56745 * swig_cast_info structures and swig_cast_info structures store pointers back
56746 * to swig_type_info structures, we need some lookup code at initialization.
56747 * The idea is that swig generates all the structures that are needed.
56748 * The runtime then collects these partially filled structures.
56749 * The SWIG_InitializeModule function takes these initial arrays out of
56750 * swig_module, and does all the lookup, filling in the swig_module.types
56751 * array with the correct data and linking the correct swig_cast_info
56752 * structures together.
56753 *
56754 * The generated swig_type_info structures are assigned staticly to an initial
56755 * array. We just loop though that array, and handle each type individually.
56756 * First we lookup if this type has been already loaded, and if so, use the
56757 * loaded structure instead of the generated one. Then we have to fill in the
56758 * cast linked list. The cast data is initially stored in something like a
56759 * two-dimensional array. Each row corresponds to a type (there are the same
56760 * number of rows as there are in the swig_type_initial array). Each entry in
56761 * a column is one of the swig_cast_info structures for that type.
56762 * The cast_initial array is actually an array of arrays, because each row has
56763 * a variable number of columns. So to actually build the cast linked list,
56764 * we find the array of casts associated with the type, and loop through it
56765 * adding the casts to the list. The one last trick we need to do is making
56766 * sure the type pointer in the swig_cast_info struct is correct.
56767 *
56768 * First off, we lookup the cast->type name to see if it is already loaded.
56769 * There are three cases to handle:
56770 * 1) If the cast->type has already been loaded AND the type we are adding
56771 * casting info to has not been loaded (it is in this module), THEN we
56772 * replace the cast->type pointer with the type pointer that has already
56773 * been loaded.
56774 * 2) If BOTH types (the one we are adding casting info to, and the
56775 * cast->type) are loaded, THEN the cast info has already been loaded by
56776 * the previous module so we just ignore it.
56777 * 3) Finally, if cast->type has not already been loaded, then we add that
56778 * swig_cast_info to the linked list (because the cast->type) pointer will
56779 * be correct.
56780 * ----------------------------------------------------------------------------- */
56781
56782 #ifdef __cplusplus
56783 extern "C" {
56784 #if 0
56785 } /* c-mode */
56786 #endif
56787 #endif
56788
56789 #if 0
56790 #define SWIGRUNTIME_DEBUG
56791 #endif
56792
56793 SWIGRUNTIME void
56794 SWIG_InitializeModule(void *clientdata) {
56795 size_t i;
56796 swig_module_info *module_head;
56797 static int init_run = 0;
56798
56799 clientdata = clientdata;
56800
56801 if (init_run) return;
56802 init_run = 1;
56803
56804 /* Initialize the swig_module */
56805 swig_module.type_initial = swig_type_initial;
56806 swig_module.cast_initial = swig_cast_initial;
56807
56808 /* Try and load any already created modules */
56809 module_head = SWIG_GetModule(clientdata);
56810 if (module_head) {
56811 swig_module.next = module_head->next;
56812 module_head->next = &swig_module;
56813 } else {
56814 /* This is the first module loaded */
56815 swig_module.next = &swig_module;
56816 SWIG_SetModule(clientdata, &swig_module);
56817 }
56818
56819 /* Now work on filling in swig_module.types */
56820 #ifdef SWIGRUNTIME_DEBUG
56821 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56822 #endif
56823 for (i = 0; i < swig_module.size; ++i) {
56824 swig_type_info *type = 0;
56825 swig_type_info *ret;
56826 swig_cast_info *cast;
56827
56828 #ifdef SWIGRUNTIME_DEBUG
56829 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56830 #endif
56831
56832 /* if there is another module already loaded */
56833 if (swig_module.next != &swig_module) {
56834 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56835 }
56836 if (type) {
56837 /* Overwrite clientdata field */
56838 #ifdef SWIGRUNTIME_DEBUG
56839 printf("SWIG_InitializeModule: found type %s\n", type->name);
56840 #endif
56841 if (swig_module.type_initial[i]->clientdata) {
56842 type->clientdata = swig_module.type_initial[i]->clientdata;
56843 #ifdef SWIGRUNTIME_DEBUG
56844 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56845 #endif
56846 }
56847 } else {
56848 type = swig_module.type_initial[i];
56849 }
56850
56851 /* Insert casting types */
56852 cast = swig_module.cast_initial[i];
56853 while (cast->type) {
56854 /* Don't need to add information already in the list */
56855 ret = 0;
56856 #ifdef SWIGRUNTIME_DEBUG
56857 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56858 #endif
56859 if (swig_module.next != &swig_module) {
56860 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56861 #ifdef SWIGRUNTIME_DEBUG
56862 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56863 #endif
56864 }
56865 if (ret) {
56866 if (type == swig_module.type_initial[i]) {
56867 #ifdef SWIGRUNTIME_DEBUG
56868 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56869 #endif
56870 cast->type = ret;
56871 ret = 0;
56872 } else {
56873 /* Check for casting already in the list */
56874 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56875 #ifdef SWIGRUNTIME_DEBUG
56876 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56877 #endif
56878 if (!ocast) ret = 0;
56879 }
56880 }
56881
56882 if (!ret) {
56883 #ifdef SWIGRUNTIME_DEBUG
56884 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
56885 #endif
56886 if (type->cast) {
56887 type->cast->prev = cast;
56888 cast->next = type->cast;
56889 }
56890 type->cast = cast;
56891 }
56892 cast++;
56893 }
56894 /* Set entry in modules->types array equal to the type */
56895 swig_module.types[i] = type;
56896 }
56897 swig_module.types[i] = 0;
56898
56899 #ifdef SWIGRUNTIME_DEBUG
56900 printf("**** SWIG_InitializeModule: Cast List ******\n");
56901 for (i = 0; i < swig_module.size; ++i) {
56902 int j = 0;
56903 swig_cast_info *cast = swig_module.cast_initial[i];
56904 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56905 while (cast->type) {
56906 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
56907 cast++;
56908 ++j;
56909 }
56910 printf("---- Total casts: %d\n",j);
56911 }
56912 printf("**** SWIG_InitializeModule: Cast List ******\n");
56913 #endif
56914 }
56915
56916 /* This function will propagate the clientdata field of type to
56917 * any new swig_type_info structures that have been added into the list
56918 * of equivalent types. It is like calling
56919 * SWIG_TypeClientData(type, clientdata) a second time.
56920 */
56921 SWIGRUNTIME void
56922 SWIG_PropagateClientData(void) {
56923 size_t i;
56924 swig_cast_info *equiv;
56925 static int init_run = 0;
56926
56927 if (init_run) return;
56928 init_run = 1;
56929
56930 for (i = 0; i < swig_module.size; i++) {
56931 if (swig_module.types[i]->clientdata) {
56932 equiv = swig_module.types[i]->cast;
56933 while (equiv) {
56934 if (!equiv->converter) {
56935 if (equiv->type && !equiv->type->clientdata)
56936 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
56937 }
56938 equiv = equiv->next;
56939 }
56940 }
56941 }
56942 }
56943
56944 #ifdef __cplusplus
56945 #if 0
56946 {
56947 /* c-mode */
56948 #endif
56949 }
56950 #endif
56951
56952
56953
56954 #ifdef __cplusplus
56955 extern "C" {
56956 #endif
56957
56958 /* Python-specific SWIG API */
56959 #define SWIG_newvarlink() SWIG_Python_newvarlink()
56960 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
56961 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
56962
56963 /* -----------------------------------------------------------------------------
56964 * global variable support code.
56965 * ----------------------------------------------------------------------------- */
56966
56967 typedef struct swig_globalvar {
56968 char *name; /* Name of global variable */
56969 PyObject *(*get_attr)(void); /* Return the current value */
56970 int (*set_attr)(PyObject *); /* Set the value */
56971 struct swig_globalvar *next;
56972 } swig_globalvar;
56973
56974 typedef struct swig_varlinkobject {
56975 PyObject_HEAD
56976 swig_globalvar *vars;
56977 } swig_varlinkobject;
56978
56979 SWIGINTERN PyObject *
56980 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
56981 return PyString_FromString("<Swig global variables>");
56982 }
56983
56984 SWIGINTERN PyObject *
56985 swig_varlink_str(swig_varlinkobject *v) {
56986 PyObject *str = PyString_FromString("(");
56987 swig_globalvar *var;
56988 for (var = v->vars; var; var=var->next) {
56989 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
56990 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
56991 }
56992 PyString_ConcatAndDel(&str,PyString_FromString(")"));
56993 return str;
56994 }
56995
56996 SWIGINTERN int
56997 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
56998 PyObject *str = swig_varlink_str(v);
56999 fprintf(fp,"Swig global variables ");
57000 fprintf(fp,"%s\n", PyString_AsString(str));
57001 Py_DECREF(str);
57002 return 0;
57003 }
57004
57005 SWIGINTERN void
57006 swig_varlink_dealloc(swig_varlinkobject *v) {
57007 swig_globalvar *var = v->vars;
57008 while (var) {
57009 swig_globalvar *n = var->next;
57010 free(var->name);
57011 free(var);
57012 var = n;
57013 }
57014 }
57015
57016 SWIGINTERN PyObject *
57017 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
57018 PyObject *res = NULL;
57019 swig_globalvar *var = v->vars;
57020 while (var) {
57021 if (strcmp(var->name,n) == 0) {
57022 res = (*var->get_attr)();
57023 break;
57024 }
57025 var = var->next;
57026 }
57027 if (res == NULL && !PyErr_Occurred()) {
57028 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57029 }
57030 return res;
57031 }
57032
57033 SWIGINTERN int
57034 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
57035 int res = 1;
57036 swig_globalvar *var = v->vars;
57037 while (var) {
57038 if (strcmp(var->name,n) == 0) {
57039 res = (*var->set_attr)(p);
57040 break;
57041 }
57042 var = var->next;
57043 }
57044 if (res == 1 && !PyErr_Occurred()) {
57045 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57046 }
57047 return res;
57048 }
57049
57050 SWIGINTERN PyTypeObject*
57051 swig_varlink_type(void) {
57052 static char varlink__doc__[] = "Swig var link object";
57053 static PyTypeObject varlink_type;
57054 static int type_init = 0;
57055 if (!type_init) {
57056 const PyTypeObject tmp
57057 = {
57058 PyObject_HEAD_INIT(NULL)
57059 0, /* Number of items in variable part (ob_size) */
57060 (char *)"swigvarlink", /* Type name (tp_name) */
57061 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
57062 0, /* Itemsize (tp_itemsize) */
57063 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
57064 (printfunc) swig_varlink_print, /* Print (tp_print) */
57065 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
57066 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
57067 0, /* tp_compare */
57068 (reprfunc) swig_varlink_repr, /* tp_repr */
57069 0, /* tp_as_number */
57070 0, /* tp_as_sequence */
57071 0, /* tp_as_mapping */
57072 0, /* tp_hash */
57073 0, /* tp_call */
57074 (reprfunc)swig_varlink_str, /* tp_str */
57075 0, /* tp_getattro */
57076 0, /* tp_setattro */
57077 0, /* tp_as_buffer */
57078 0, /* tp_flags */
57079 varlink__doc__, /* tp_doc */
57080 0, /* tp_traverse */
57081 0, /* tp_clear */
57082 0, /* tp_richcompare */
57083 0, /* tp_weaklistoffset */
57084 #if PY_VERSION_HEX >= 0x02020000
57085 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
57086 #endif
57087 #if PY_VERSION_HEX >= 0x02030000
57088 0, /* tp_del */
57089 #endif
57090 #ifdef COUNT_ALLOCS
57091 0,0,0,0 /* tp_alloc -> tp_next */
57092 #endif
57093 };
57094 varlink_type = tmp;
57095 varlink_type.ob_type = &PyType_Type;
57096 type_init = 1;
57097 }
57098 return &varlink_type;
57099 }
57100
57101 /* Create a variable linking object for use later */
57102 SWIGINTERN PyObject *
57103 SWIG_Python_newvarlink(void) {
57104 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
57105 if (result) {
57106 result->vars = 0;
57107 }
57108 return ((PyObject*) result);
57109 }
57110
57111 SWIGINTERN void
57112 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
57113 swig_varlinkobject *v = (swig_varlinkobject *) p;
57114 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
57115 if (gv) {
57116 size_t size = strlen(name)+1;
57117 gv->name = (char *)malloc(size);
57118 if (gv->name) {
57119 strncpy(gv->name,name,size);
57120 gv->get_attr = get_attr;
57121 gv->set_attr = set_attr;
57122 gv->next = v->vars;
57123 }
57124 }
57125 v->vars = gv;
57126 }
57127
57128 SWIGINTERN PyObject *
57129 SWIG_globals() {
57130 static PyObject *_SWIG_globals = 0;
57131 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
57132 return _SWIG_globals;
57133 }
57134
57135 /* -----------------------------------------------------------------------------
57136 * constants/methods manipulation
57137 * ----------------------------------------------------------------------------- */
57138
57139 /* Install Constants */
57140 SWIGINTERN void
57141 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
57142 PyObject *obj = 0;
57143 size_t i;
57144 for (i = 0; constants[i].type; ++i) {
57145 switch(constants[i].type) {
57146 case SWIG_PY_POINTER:
57147 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
57148 break;
57149 case SWIG_PY_BINARY:
57150 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
57151 break;
57152 default:
57153 obj = 0;
57154 break;
57155 }
57156 if (obj) {
57157 PyDict_SetItemString(d, constants[i].name, obj);
57158 Py_DECREF(obj);
57159 }
57160 }
57161 }
57162
57163 /* -----------------------------------------------------------------------------*/
57164 /* Fix SwigMethods to carry the callback ptrs when needed */
57165 /* -----------------------------------------------------------------------------*/
57166
57167 SWIGINTERN void
57168 SWIG_Python_FixMethods(PyMethodDef *methods,
57169 swig_const_info *const_table,
57170 swig_type_info **types,
57171 swig_type_info **types_initial) {
57172 size_t i;
57173 for (i = 0; methods[i].ml_name; ++i) {
57174 const char *c = methods[i].ml_doc;
57175 if (c && (c = strstr(c, "swig_ptr: "))) {
57176 int j;
57177 swig_const_info *ci = 0;
57178 const char *name = c + 10;
57179 for (j = 0; const_table[j].type; ++j) {
57180 if (strncmp(const_table[j].name, name,
57181 strlen(const_table[j].name)) == 0) {
57182 ci = &(const_table[j]);
57183 break;
57184 }
57185 }
57186 if (ci) {
57187 size_t shift = (ci->ptype) - types;
57188 swig_type_info *ty = types_initial[shift];
57189 size_t ldoc = (c - methods[i].ml_doc);
57190 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
57191 char *ndoc = (char*)malloc(ldoc + lptr + 10);
57192 if (ndoc) {
57193 char *buff = ndoc;
57194 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
57195 if (ptr) {
57196 strncpy(buff, methods[i].ml_doc, ldoc);
57197 buff += ldoc;
57198 strncpy(buff, "swig_ptr: ", 10);
57199 buff += 10;
57200 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
57201 methods[i].ml_doc = ndoc;
57202 }
57203 }
57204 }
57205 }
57206 }
57207 }
57208
57209 #ifdef __cplusplus
57210 }
57211 #endif
57212
57213 /* -----------------------------------------------------------------------------*
57214 * Partial Init method
57215 * -----------------------------------------------------------------------------*/
57216
57217 #ifdef __cplusplus
57218 extern "C"
57219 #endif
57220 SWIGEXPORT void SWIG_init(void) {
57221 PyObject *m, *d;
57222
57223 /* Fix SwigMethods to carry the callback ptrs when needed */
57224 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
57225
57226 m = Py_InitModule((char *) SWIG_name, SwigMethods);
57227 d = PyModule_GetDict(m);
57228
57229 SWIG_InitializeModule(0);
57230 SWIG_InstallConstants(d,swig_const_table);
57231
57232
57233
57234 #ifndef wxPyUSE_EXPORT
57235 // Make our API structure a CObject so other modules can import it
57236 // from this module.
57237 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
57238 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
57239 Py_XDECREF(cobj);
57240 #endif
57241
57242 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
57243 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
57244 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
57245 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
57246 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
57247 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
57248 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
57249 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
57250 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
57251 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
57252 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
57253 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
57254 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
57255 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
57256 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
57257 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
57258 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
57259 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
57260 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
57261 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
57262 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
57263 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
57264 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
57265 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
57266 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
57267 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
57268 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
57269 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
57270 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
57271 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
57272 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
57273 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
57274 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
57275 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
57276 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
57277 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
57278 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
57279 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
57280 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
57281 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
57282 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
57283 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
57284 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
57285 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
57286 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
57287 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
57288 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
57289 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
57290 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
57291 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
57292 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
57293 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
57294 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
57295 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
57296 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
57297 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
57298 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
57299 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
57300 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
57301 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
57302 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
57303 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
57304 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
57305 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
57306 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
57307 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
57308 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
57309 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
57310 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
57311 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
57312 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
57313 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
57314 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
57315 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
57316 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
57317 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
57318 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
57319 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
57320 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
57321 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
57322 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
57323 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
57324 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
57325 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
57326 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
57327 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
57328 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
57329 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
57330 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
57331 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
57332 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
57333 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
57334 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
57335 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
57336 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
57337 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
57338 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
57339 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
57340 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
57341 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
57342 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
57343 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
57344 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
57345 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
57346 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
57347 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
57348 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
57349 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
57350 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
57351 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
57352 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
57353 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
57354 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
57355 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
57356 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
57357 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
57358 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
57359 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
57360 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
57361 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
57362 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
57363 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
57364 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
57365 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
57366 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
57367 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
57368 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
57369 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
57370 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
57371 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
57372 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
57373 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
57374 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
57375 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
57376 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
57377 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
57378 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
57379 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
57380 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
57381 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
57382 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
57383 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
57384 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
57385 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
57386 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
57387 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
57388 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
57389 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
57390 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
57391 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
57392 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
57393 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
57394 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
57395 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
57396 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
57397 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
57398 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
57399 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
57400 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
57401 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
57402 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
57403 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
57404 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
57405 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
57406 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
57407 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
57408 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
57409 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
57410 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
57411 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
57412 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
57413 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
57414 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
57415 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
57416 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
57417 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
57418 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
57419 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
57420 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
57421 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
57422 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
57423 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
57424 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
57425 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
57426 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
57427 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
57428 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
57429 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
57430 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
57431 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
57432 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57433 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57434 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57435 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57436 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57437 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57438 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57439 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57440 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57441 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57442 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57443 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57444 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57445 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57446 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57447 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57448 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57449 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57450 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57451 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57452 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57453 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57454 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57455 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57456 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57457 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57458 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57459 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57460 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57461 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57462 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57463 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57464 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57465 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57466 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57467 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57468 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57469 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57470 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57471 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57472 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57473 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57474 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57475 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57476 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57477 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57478 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57479 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57480 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57481 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57482 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57483 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57484 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57485 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57486 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57487 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57488 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57489 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57490 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57491 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57492 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57493 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57494 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57495 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57496 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57497 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57498 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57499 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57500 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57501 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57502 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57503 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57504 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57505 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57506 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57507 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57508 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57509 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57510 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57511 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57512 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57513 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57514 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57515 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57516 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57517 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57518 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57519 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57520 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57521 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57522 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57523 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57524 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57525 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57526 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57527 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57528 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57529 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57530 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57531 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57532 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57533 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57534 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57535 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57536 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57537 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57538 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57539 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57540 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57541 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57542 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57543 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57544 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57545 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57546 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57547 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57548 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57549 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57550 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57551 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57552 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57553 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57554 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57555 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57556 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57557 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57558 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57559 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57560 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57561 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57562 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57563 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57564 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57565 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57566 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57567 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57568 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57569 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57570 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57571 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57572 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57573 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57574 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57575 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57576 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57577 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57578 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57579 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57580 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57581 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57582 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57583 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57584 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57585 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57586 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57587 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57588 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57589 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57590 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57591 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57592 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57593 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57594 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57595 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57596 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57597 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57598 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57599 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57600 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57601 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57602 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57603 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57604 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57605 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57606 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57607 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57608 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57609 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57610 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57611 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57612 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57613 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57614 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57615 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57616 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57617 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57618 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57619 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57620 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57621 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57622 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57623 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57624 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57625 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57626 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57627 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57628 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57629 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57630 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57631 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57632 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57633 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57634 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57635 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57636 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57637 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57638 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57639 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57640 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57641 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57642 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57643 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57644 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57645 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57646 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57647 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57648 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57649 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57650 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57651 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57652 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57653 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57654 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57655 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57656 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57657 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57658 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57659 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57660 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57661 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57662 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57663 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57664 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57665 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57666 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57667 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57668 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57669 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57670 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57671 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57672 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57673 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57674 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57675 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57676 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57677 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57678 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57679 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57680 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57681 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57682 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57683 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57684 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57685 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57686 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57687 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57688 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57689 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57690 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57691 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57692 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57693 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57694 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57695 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57696 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57697 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57698 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57699 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57700 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57701 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57702 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57703 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57704 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57705 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57706 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57707 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57708 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57709 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57710 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57711 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57712 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57713 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57714 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57715 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57716 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57717 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57718 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57719 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57720 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57721 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57722 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57723 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57724 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57725 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57726 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57727 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57728 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57729 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57730 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57731 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57732 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57733 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57734 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57735 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57736 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57737 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57738 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57739 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57740 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57741 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57742 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57743 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57744 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57745 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57746 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57747 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57748 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57749 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57750 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57751 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57752 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57753 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57754 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57755 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57756 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57757 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57758 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57759 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57760 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57761 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57762 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57763 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57764 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57765 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57766 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57767 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57768 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57769 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57770 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57771 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57772 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57773 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57774 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57775 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57776 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57777 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57778 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57779 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57780 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57781 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57782 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57783 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57784 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57785 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57786 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57787 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57788 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57789 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57790 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57791 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57792 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57793 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57794 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57795 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57796 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57797 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57798 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57799 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57800 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57801 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57802 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57803 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57804 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57805 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57806 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57807 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57808 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57809 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57810 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57811 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57812 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57813 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57814 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57815 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57816 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57817 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57818 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57819 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57820 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57821 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57822 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57823 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57824 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57825 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57826 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57827 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57828 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57829 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57830 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57831 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57832 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57833 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57834 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57835 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57836 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57837 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57838 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57839 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57840 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57841 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57842 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57843 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57844 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57845 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57846 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57847 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57848 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57849 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57850 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57851 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57852 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57853 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57854 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57855 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57856 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57857 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57858 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57859 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57860 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57861 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57862 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57863 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57864 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57865 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57866 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57867 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57868 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57869 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57870 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57871 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57872 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57873 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57874 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57875 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57876 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57877 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57878 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57879 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57880 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57881 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57882 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
57883 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
57884 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
57885 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
57886 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
57887 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
57888 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
57889 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
57890 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
57891 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
57892 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
57893 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
57894 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
57895 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
57896 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
57897 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
57898 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
57899 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
57900 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
57901
57902 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
57903
57904
57905 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
57906
57907 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
57908 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
57909 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
57910 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
57911 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
57912 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
57913 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
57914 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
57915 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
57916 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
57917 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
57918 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
57919 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
57920 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
57921 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
57922 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
57923 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
57924 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
57925 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
57926 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
57927 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
57928 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
57929 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
57930 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
57931 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
57932 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
57933 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
57934 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
57935 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
57936 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
57937 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
57938 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
57939 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
57940 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
57941 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
57942 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
57943 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
57944 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
57945 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
57946 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
57947 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
57948 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
57949 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
57950 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
57951 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
57952 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
57953 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
57954 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
57955 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
57956 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
57957 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
57958 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
57959 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
57960 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
57961 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
57962 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
57963 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
57964 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
57965 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
57966 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
57967 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
57968 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
57969 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
57970 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
57971 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
57972 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
57973 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
57974 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
57975 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
57976 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
57977 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
57978 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
57979 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
57980 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
57981 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
57982 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
57983 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
57984 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
57985 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
57986 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
57987 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
57988 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
57989 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
57990 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
57991 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
57992 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
57993 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
57994 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
57995 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
57996 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
57997 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
57998 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
57999 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
58000 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
58001 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
58002 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
58003 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
58004 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
58005 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
58006 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
58007 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
58008 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
58009 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
58010 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
58011 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
58012 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
58013 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
58014 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
58015 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
58016 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
58017 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
58018 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
58019 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
58020 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
58021 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
58022 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
58023 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
58024 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
58025 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
58026 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
58027 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
58028 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
58029 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
58030 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
58031 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
58032 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
58033 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
58034 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
58035 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
58036 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
58037 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
58038 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
58039 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
58040 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
58041 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
58042 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
58043 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
58044 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
58045 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
58046 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
58047 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
58048 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
58049 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
58050 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
58051 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
58052 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
58053 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
58054 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
58055 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
58056 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
58057 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
58058 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
58059 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
58060 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
58061 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
58062 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
58063 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
58064 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
58065 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
58066 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
58067 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
58068 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
58069 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
58070 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
58071 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
58072 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
58073 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
58074 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
58075 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
58076 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
58077 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
58078 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
58079 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
58080 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
58081 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
58082 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
58083 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
58084 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
58085 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
58086 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
58087 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
58088 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
58089 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
58090 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
58091 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
58092 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
58093 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
58094 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
58095 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
58096 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
58097 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
58098 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
58099 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
58100 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
58101 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
58102 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
58103 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
58104 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
58105 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
58106 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
58107 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
58108 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
58109 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
58110 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
58111 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
58112 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
58113 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
58114 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
58115 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
58116 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
58117 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
58118 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
58119 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
58120 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
58121
58122 // Initialize threading, some globals and such
58123 __wxPyPreStart(d);
58124
58125
58126 // Although these are defined in __version__ they need to be here too so
58127 // that an assert can be done to ensure that the wxPython and the wxWindows
58128 // versions match.
58129 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
58130 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
58131 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
58132
58133 }
58134
wxWidgets (Impactor)