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


c2de7b0319343cf48e8c9faafa3dac9b72d70f6d
[wxWidgets.git] / wxPython / src / mac / _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_wxMouseEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMoveEvent swig_types[79]
2546 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNcPaintEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNotifyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxObject swig_types[83]
2550 #define SWIGTYPE_p_wxOutputStream swig_types[84]
2551 #define SWIGTYPE_p_wxPCXHandler swig_types[85]
2552 #define SWIGTYPE_p_wxPNGHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNMHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPaintEvent swig_types[88]
2555 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaperSize swig_types[90]
2557 #define SWIGTYPE_p_wxPoint swig_types[91]
2558 #define SWIGTYPE_p_wxPoint2D swig_types[92]
2559 #define SWIGTYPE_p_wxPropagateOnce swig_types[93]
2560 #define SWIGTYPE_p_wxPropagationDisabler swig_types[94]
2561 #define SWIGTYPE_p_wxPyApp swig_types[95]
2562 #define SWIGTYPE_p_wxPyCommandEvent swig_types[96]
2563 #define SWIGTYPE_p_wxPyDropTarget swig_types[97]
2564 #define SWIGTYPE_p_wxPyEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[99]
2566 #define SWIGTYPE_p_wxPyImageHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyInputStream swig_types[101]
2568 #define SWIGTYPE_p_wxPySizer swig_types[102]
2569 #define SWIGTYPE_p_wxPyValidator swig_types[103]
2570 #define SWIGTYPE_p_wxQuantize swig_types[104]
2571 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[105]
2572 #define SWIGTYPE_p_wxRealPoint swig_types[106]
2573 #define SWIGTYPE_p_wxRect swig_types[107]
2574 #define SWIGTYPE_p_wxRegion swig_types[108]
2575 #define SWIGTYPE_p_wxScrollEvent swig_types[109]
2576 #define SWIGTYPE_p_wxScrollWinEvent swig_types[110]
2577 #define SWIGTYPE_p_wxSetCursorEvent swig_types[111]
2578 #define SWIGTYPE_p_wxShowEvent swig_types[112]
2579 #define SWIGTYPE_p_wxSize swig_types[113]
2580 #define SWIGTYPE_p_wxSizeEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSizer swig_types[115]
2582 #define SWIGTYPE_p_wxSizerItem swig_types[116]
2583 #define SWIGTYPE_p_wxStaticBox swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[119]
2586 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[120]
2587 #define SWIGTYPE_p_wxTIFFHandler swig_types[121]
2588 #define SWIGTYPE_p_wxToolTip swig_types[122]
2589 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[123]
2590 #define SWIGTYPE_p_wxValidator swig_types[124]
2591 #define SWIGTYPE_p_wxVisualAttributes swig_types[125]
2592 #define SWIGTYPE_p_wxWindow swig_types[126]
2593 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[127]
2594 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[128]
2595 #define SWIGTYPE_p_wxXPMHandler swig_types[129]
2596 #define SWIGTYPE_p_wxZipFSHandler swig_types[130]
2597 static swig_type_info *swig_types[132];
2598 static swig_module_info swig_module = {swig_types, 131, 0, 0, 0, 0};
2599 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2600 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2601
2602 /* -------- TYPES TABLE (END) -------- */
2603
2604 #if (PY_VERSION_HEX <= 0x02000000)
2605 # if !defined(SWIG_PYTHON_CLASSIC)
2606 # error "This python version requires to use swig with the '-classic' option"
2607 # endif
2608 #endif
2609 #if (PY_VERSION_HEX <= 0x02020000)
2610 # error "This python version requires to use swig with the '-nomodern' option"
2611 #endif
2612 #if (PY_VERSION_HEX <= 0x02020000)
2613 # error "This python version requires to use swig with the '-nomodernargs' option"
2614 #endif
2615 #ifndef METH_O
2616 # error "This python version requires to use swig with the '-nofastunpack' option"
2617 #endif
2618
2619 /*-----------------------------------------------
2620 @(target):= _core_.so
2621 ------------------------------------------------*/
2622 #define SWIG_init init_core_
2623
2624 #define SWIG_name "_core_"
2625
2626 #define SWIGVERSION 0x010329
2627
2628
2629 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2630 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2631
2632
2633 #include <stdexcept>
2634
2635
2636 namespace swig {
2637 class PyObject_ptr {
2638 protected:
2639 PyObject *_obj;
2640
2641 public:
2642 PyObject_ptr() :_obj(0)
2643 {
2644 }
2645
2646 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2647 {
2648 Py_XINCREF(_obj);
2649 }
2650
2651 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2652 {
2653 if (initial_ref) Py_XINCREF(_obj);
2654 }
2655
2656 PyObject_ptr & operator=(const PyObject_ptr& item)
2657 {
2658 Py_XINCREF(item._obj);
2659 Py_XDECREF(_obj);
2660 _obj = item._obj;
2661 return *this;
2662 }
2663
2664 ~PyObject_ptr()
2665 {
2666 Py_XDECREF(_obj);
2667 }
2668
2669 operator PyObject *() const
2670 {
2671 return _obj;
2672 }
2673
2674 PyObject *operator->() const
2675 {
2676 return _obj;
2677 }
2678 };
2679 }
2680
2681
2682 namespace swig {
2683 struct PyObject_var : PyObject_ptr {
2684 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2685
2686 PyObject_var & operator = (PyObject* obj)
2687 {
2688 Py_XDECREF(_obj);
2689 _obj = obj;
2690 return *this;
2691 }
2692 };
2693 }
2694
2695
2696 #include "wx/wxPython/wxPython_int.h"
2697 #include "wx/wxPython/pyclasses.h"
2698 #include "wx/wxPython/twoitem.h"
2699
2700
2701 #ifndef wxPyUSE_EXPORT
2702 // Helper functions for dealing with SWIG objects and such. These are
2703 // located here so they know about the SWIG types and functions declared
2704 // in the wrapper code.
2705
2706 #include <wx/hashmap.h>
2707 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2708
2709
2710 // Maintains a hashmap of className to swig_type_info pointers. Given the
2711 // name of a class either looks up the type info in the cache, or scans the
2712 // SWIG tables for it.
2713 extern PyObject* wxPyPtrTypeMap;
2714 static
2715 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2716
2717 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2718
2719 if (typeInfoCache == NULL)
2720 typeInfoCache = new wxPyTypeInfoHashMap;
2721
2722 wxString name(className);
2723 swig_type_info* swigType = (*typeInfoCache)[name];
2724
2725 if (! swigType) {
2726 // it wasn't in the cache, so look it up from SWIG
2727 name.Append(wxT(" *"));
2728 swigType = SWIG_TypeQuery(name.mb_str());
2729
2730 // if it still wasn't found, try looking for a mapped name
2731 if (!swigType) {
2732 PyObject* item;
2733 name = className;
2734
2735 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2736 (char*)(const char*)name.mbc_str())) != NULL) {
2737 name = wxString(PyString_AsString(item), *wxConvCurrent);
2738 name.Append(wxT(" *"));
2739 swigType = SWIG_TypeQuery(name.mb_str());
2740 }
2741 }
2742 if (swigType) {
2743 // and add it to the map if found
2744 (*typeInfoCache)[className] = swigType;
2745 }
2746 }
2747 return swigType;
2748 }
2749
2750
2751 // Check if a class name is a type known to SWIG
2752 bool wxPyCheckSwigType(const wxChar* className) {
2753
2754 swig_type_info* swigType = wxPyFindSwigType(className);
2755 return swigType != NULL;
2756 }
2757
2758
2759 // Given a pointer to a C++ object and a class name, construct a Python proxy
2760 // object for it.
2761 PyObject* wxPyConstructObject(void* ptr,
2762 const wxChar* className,
2763 int setThisOwn) {
2764
2765 swig_type_info* swigType = wxPyFindSwigType(className);
2766 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2767
2768 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2769 }
2770
2771
2772 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2773 // Ensures that the proxy object is of the specified (or derived) type. If
2774 // not able to perform the conversion then a Python exception is set and the
2775 // error should be handled properly in the caller. Returns True on success.
2776 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2777 const wxChar* className) {
2778
2779 swig_type_info* swigType = wxPyFindSwigType(className);
2780 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2781
2782 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2783 }
2784
2785
2786
2787 // Make a SWIGified pointer object suitable for a .this attribute
2788 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2789
2790 PyObject* robj = NULL;
2791
2792 swig_type_info* swigType = wxPyFindSwigType(className);
2793 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2794
2795 robj = PySwigObject_New(ptr, swigType, 0);
2796 return robj;
2797 }
2798
2799
2800 // Python's PyInstance_Check does not return True for instances of new-style
2801 // classes. This should get close enough for both new and old classes but I
2802 // should re-evaluate the need for doing instance checks...
2803 bool wxPyInstance_Check(PyObject* obj) {
2804 return PyObject_HasAttrString(obj, "__class__") != 0;
2805 }
2806
2807
2808 // This one checks if the object is an instance of a SWIG proxy class (it has
2809 // a .this attribute, and the .this attribute is a PySwigObject.)
2810 bool wxPySwigInstance_Check(PyObject* obj) {
2811 static PyObject* this_str = NULL;
2812 if (this_str == NULL)
2813 this_str = PyString_FromString("this");
2814
2815 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2816 if (this_attr) {
2817 bool retval = (PySwigObject_Check(this_attr) != 0);
2818 Py_DECREF(this_attr);
2819 return retval;
2820 }
2821
2822 PyErr_Clear();
2823 return false;
2824 }
2825
2826
2827 // Export a C API in a struct. Other modules will be able to load this from
2828 // the wx._core_ module and will then have safe access to these functions,
2829 // even if they are located in another shared library.
2830 static wxPyCoreAPI API = {
2831
2832 wxPyCheckSwigType,
2833 wxPyConstructObject,
2834 wxPyConvertSwigPtr,
2835 wxPyMakeSwigPtr,
2836
2837 wxPyBeginAllowThreads,
2838 wxPyEndAllowThreads,
2839 wxPyBeginBlockThreads,
2840 wxPyEndBlockThreads,
2841
2842 wxPy_ConvertList,
2843
2844 wxString_in_helper,
2845 Py2wxString,
2846 wx2PyString,
2847
2848 byte_LIST_helper,
2849 int_LIST_helper,
2850 long_LIST_helper,
2851 string_LIST_helper,
2852 wxPoint_LIST_helper,
2853 wxBitmap_LIST_helper,
2854 wxString_LIST_helper,
2855 wxAcceleratorEntry_LIST_helper,
2856
2857 wxSize_helper,
2858 wxPoint_helper,
2859 wxRealPoint_helper,
2860 wxRect_helper,
2861 wxColour_helper,
2862 wxPoint2D_helper,
2863
2864 wxPySimple_typecheck,
2865 wxColour_typecheck,
2866
2867 wxPyCBH_setCallbackInfo,
2868 wxPyCBH_findCallback,
2869 wxPyCBH_callCallback,
2870 wxPyCBH_callCallbackObj,
2871 wxPyCBH_delete,
2872
2873 wxPyMake_wxObject,
2874 wxPyMake_wxSizer,
2875 wxPyPtrTypeMap_Add,
2876 wxPy2int_seq_helper,
2877 wxPy4int_seq_helper,
2878 wxArrayString2PyList_helper,
2879 wxArrayInt2PyList_helper,
2880
2881 wxPyClientData_dtor,
2882 wxPyUserData_dtor,
2883 wxPyOORClientData_dtor,
2884
2885 wxPyCBInputStream_create,
2886 wxPyCBInputStream_copy,
2887
2888 wxPyInstance_Check,
2889 wxPySwigInstance_Check,
2890
2891 wxPyCheckForApp
2892
2893 };
2894
2895 #endif
2896
2897
2898 #if !WXWIN_COMPATIBILITY_2_4
2899 #define wxHIDE_READONLY 0
2900 #endif
2901
2902
2903 #define SWIG_From_long PyInt_FromLong
2904
2905
2906 SWIGINTERNINLINE PyObject *
2907 SWIG_From_int (int value)
2908 {
2909 return SWIG_From_long (value);
2910 }
2911
2912 static const wxString wxPyEmptyString(wxEmptyString);
2913 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2914 return self->GetClassInfo()->GetClassName();
2915 }
2916 SWIGINTERN void wxObject_Destroy(wxObject *self){
2917 delete self;
2918 }
2919
2920 #ifndef __WXMAC__
2921 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2922 #endif
2923
2924
2925 #include <limits.h>
2926 #ifndef LLONG_MIN
2927 # define LLONG_MIN LONG_LONG_MIN
2928 #endif
2929 #ifndef LLONG_MAX
2930 # define LLONG_MAX LONG_LONG_MAX
2931 #endif
2932 #ifndef ULLONG_MAX
2933 # define ULLONG_MAX ULONG_LONG_MAX
2934 #endif
2935
2936
2937 SWIGINTERN int
2938 SWIG_AsVal_long (PyObject* obj, long* val)
2939 {
2940 if (PyNumber_Check(obj)) {
2941 if (val) *val = PyInt_AsLong(obj);
2942 return SWIG_OK;
2943 }
2944 return SWIG_TypeError;
2945 }
2946
2947
2948 SWIGINTERN int
2949 SWIG_AsVal_int (PyObject * obj, int *val)
2950 {
2951 long v;
2952 int res = SWIG_AsVal_long (obj, &v);
2953 if (SWIG_IsOK(res)) {
2954 if ((v < INT_MIN || v > INT_MAX)) {
2955 return SWIG_OverflowError;
2956 } else {
2957 if (val) *val = static_cast< int >(v);
2958 }
2959 }
2960 return res;
2961 }
2962
2963 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2964 wxSize temp, *obj = &temp;
2965 if ( other == Py_None ) return false;
2966 if ( ! wxSize_helper(other, &obj) ) {
2967 PyErr_Clear();
2968 return false;
2969 }
2970 return self->operator==(*obj);
2971 }
2972 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2973 wxSize temp, *obj = &temp;
2974 if ( other == Py_None ) return true;
2975 if ( ! wxSize_helper(other, &obj)) {
2976 PyErr_Clear();
2977 return true;
2978 }
2979 return self->operator!=(*obj);
2980 }
2981
2982 #include <float.h>
2983
2984
2985 SWIGINTERN int
2986 SWIG_AsVal_double (PyObject *obj, double* val)
2987 {
2988 if (PyNumber_Check(obj)) {
2989 if (val) *val = PyFloat_AsDouble(obj);
2990 return SWIG_OK;
2991 }
2992 return SWIG_TypeError;
2993 }
2994
2995
2996 SWIGINTERN int
2997 SWIG_AsVal_float (PyObject * obj, float *val)
2998 {
2999 double v;
3000 int res = SWIG_AsVal_double (obj, &v);
3001 if (SWIG_IsOK(res)) {
3002 if ((v < -FLT_MAX || v > FLT_MAX)) {
3003 return SWIG_OverflowError;
3004 } else {
3005 if (val) *val = static_cast< float >(v);
3006 }
3007 }
3008 return res;
3009 }
3010
3011 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3012 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3013 PyObject* tup = PyTuple_New(2);
3014 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3015 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3016 wxPyEndBlockThreads(blocked);
3017 return tup;
3018 }
3019
3020 #define SWIG_From_double PyFloat_FromDouble
3021
3022 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3023 wxRealPoint temp, *obj = &temp;
3024 if ( other == Py_None ) return false;
3025 if ( ! wxRealPoint_helper(other, &obj) ) {
3026 PyErr_Clear();
3027 return false;
3028 }
3029 return self->operator==(*obj);
3030 }
3031 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3032 wxRealPoint temp, *obj = &temp;
3033 if ( other == Py_None ) return true;
3034 if ( ! wxRealPoint_helper(other, &obj)) {
3035 PyErr_Clear();
3036 return true;
3037 }
3038 return self->operator!=(*obj);
3039 }
3040 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3041 self->x = x;
3042 self->y = y;
3043 }
3044 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3045 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3046 PyObject* tup = PyTuple_New(2);
3047 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3048 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3049 wxPyEndBlockThreads(blocked);
3050 return tup;
3051 }
3052 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3053 wxPoint temp, *obj = &temp;
3054 if ( other == Py_None ) return false;
3055 if ( ! wxPoint_helper(other, &obj) ) {
3056 PyErr_Clear();
3057 return false;
3058 }
3059 return self->operator==(*obj);
3060 }
3061 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3062 wxPoint temp, *obj = &temp;
3063 if ( other == Py_None ) return true;
3064 if ( ! wxPoint_helper(other, &obj)) {
3065 PyErr_Clear();
3066 return true;
3067 }
3068 return self->operator!=(*obj);
3069 }
3070 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3071 self->x = x;
3072 self->y = y;
3073 }
3074 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3075 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3076 PyObject* tup = PyTuple_New(2);
3077 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3078 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3079 wxPyEndBlockThreads(blocked);
3080 return tup;
3081 }
3082 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3083 wxRect temp, *obj = &temp;
3084 if ( other == Py_None ) return false;
3085 if ( ! wxRect_helper(other, &obj) ) {
3086 PyErr_Clear();
3087 return false;
3088 }
3089 return self->operator==(*obj);
3090 }
3091 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3092 wxRect temp, *obj = &temp;
3093 if ( other == Py_None ) return true;
3094 if ( ! wxRect_helper(other, &obj)) {
3095 PyErr_Clear();
3096 return true;
3097 }
3098 return self->operator!=(*obj);
3099 }
3100 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3101 self->x = x;
3102 self->y = y;
3103 self->width = width;
3104 self->height = height;
3105 }
3106 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3107 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3108 PyObject* tup = PyTuple_New(4);
3109 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3110 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3111 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3112 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3113 wxPyEndBlockThreads(blocked);
3114 return tup;
3115 }
3116
3117 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3118 wxRegion reg1(*r1);
3119 wxRegion reg2(*r2);
3120 wxRect dest(0,0,0,0);
3121 PyObject* obj;
3122
3123 reg1.Intersect(reg2);
3124 dest = reg1.GetBox();
3125
3126 if (dest != wxRect(0,0,0,0)) {
3127 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3128 wxRect* newRect = new wxRect(dest);
3129 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3130 wxPyEndBlockThreads(blocked);
3131 return obj;
3132 }
3133 Py_INCREF(Py_None);
3134 return Py_None;
3135 }
3136
3137 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3138 wxPoint2D temp, *obj = &temp;
3139 if ( other == Py_None ) return false;
3140 if ( ! wxPoint2D_helper(other, &obj) ) {
3141 PyErr_Clear();
3142 return false;
3143 }
3144 return self->operator==(*obj);
3145 }
3146 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3147 wxPoint2D temp, *obj = &temp;
3148 if ( other == Py_None ) return true;
3149 if ( ! wxPoint2D_helper(other, &obj)) {
3150 PyErr_Clear();
3151 return true;
3152 }
3153 return self->operator!=(*obj);
3154 }
3155 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3156 self->m_x = x;
3157 self->m_y = y;
3158 }
3159 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3161 PyObject* tup = PyTuple_New(2);
3162 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3163 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3164 wxPyEndBlockThreads(blocked);
3165 return tup;
3166 }
3167
3168 #include "wx/wxPython/pyistream.h"
3169
3170 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3171 wxInputStream* wxis = wxPyCBInputStream::create(p);
3172 if (wxis)
3173 return new wxPyInputStream(wxis);
3174 else
3175 return NULL;
3176 }
3177
3178 SWIGINTERN swig_type_info*
3179 SWIG_pchar_descriptor()
3180 {
3181 static int init = 0;
3182 static swig_type_info* info = 0;
3183 if (!init) {
3184 info = SWIG_TypeQuery("_p_char");
3185 init = 1;
3186 }
3187 return info;
3188 }
3189
3190
3191 SWIGINTERNINLINE PyObject *
3192 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3193 {
3194 if (carray) {
3195 if (size > INT_MAX) {
3196 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3197 return pchar_descriptor ?
3198 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3199 } else {
3200 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3201 }
3202 } else {
3203 return SWIG_Py_Void();
3204 }
3205 }
3206
3207
3208 SWIGINTERNINLINE PyObject *
3209 SWIG_From_char (char c)
3210 {
3211 return SWIG_FromCharPtrAndSize(&c,1);
3212 }
3213
3214
3215 SWIGINTERNINLINE PyObject*
3216 SWIG_From_unsigned_SS_long (unsigned long value)
3217 {
3218 return (value > LONG_MAX) ?
3219 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3220 }
3221
3222
3223 SWIGINTERNINLINE PyObject *
3224 SWIG_From_size_t (size_t value)
3225 {
3226 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3227 }
3228
3229
3230 SWIGINTERN int
3231 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3232 {
3233 if (PyString_Check(obj)) {
3234 char *cstr; Py_ssize_t len;
3235 PyString_AsStringAndSize(obj, &cstr, &len);
3236 if (cptr) {
3237 if (alloc) {
3238 /*
3239 In python the user should not be able to modify the inner
3240 string representation. To warranty that, if you define
3241 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3242 buffer is always returned.
3243
3244 The default behavior is just to return the pointer value,
3245 so, be careful.
3246 */
3247 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3248 if (*alloc != SWIG_OLDOBJ)
3249 #else
3250 if (*alloc == SWIG_NEWOBJ)
3251 #endif
3252 {
3253 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3254 *alloc = SWIG_NEWOBJ;
3255 }
3256 else {
3257 *cptr = cstr;
3258 *alloc = SWIG_OLDOBJ;
3259 }
3260 } else {
3261 *cptr = PyString_AsString(obj);
3262 }
3263 }
3264 if (psize) *psize = len + 1;
3265 return SWIG_OK;
3266 } else {
3267 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3268 if (pchar_descriptor) {
3269 void* vptr = 0;
3270 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3271 if (cptr) *cptr = (char *) vptr;
3272 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3273 if (alloc) *alloc = SWIG_OLDOBJ;
3274 return SWIG_OK;
3275 }
3276 }
3277 }
3278 return SWIG_TypeError;
3279 }
3280
3281
3282 SWIGINTERN int
3283 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3284 {
3285 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3286 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3287 if (SWIG_IsOK(res)) {
3288 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3289 if (csize <= size) {
3290 if (val) {
3291 if (csize) memcpy(val, cptr, csize*sizeof(char));
3292 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3293 }
3294 if (alloc == SWIG_NEWOBJ) {
3295 delete[] cptr;
3296 res = SWIG_DelNewMask(res);
3297 }
3298 return res;
3299 }
3300 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3301 }
3302 return SWIG_TypeError;
3303 }
3304
3305
3306 SWIGINTERN int
3307 SWIG_AsVal_char (PyObject * obj, char *val)
3308 {
3309 int res = SWIG_AsCharArray(obj, val, 1);
3310 if (!SWIG_IsOK(res)) {
3311 long v;
3312 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3313 if (SWIG_IsOK(res)) {
3314 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3315 if (val) *val = static_cast< char >(v);
3316 } else {
3317 res = SWIG_OverflowError;
3318 }
3319 }
3320 }
3321 return res;
3322 }
3323
3324 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3325 // We use only strings for the streams, not unicode
3326 PyObject* str = PyObject_Str(obj);
3327 if (! str) {
3328 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3329 return;
3330 }
3331 self->Write(PyString_AS_STRING(str),
3332 PyString_GET_SIZE(str));
3333 Py_DECREF(str);
3334 }
3335
3336 #include "wx/wxPython/pyistream.h"
3337
3338
3339 class wxPyFileSystemHandler : public wxFileSystemHandler
3340 {
3341 public:
3342 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3343
3344 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3345 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3346 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3347 DEC_PYCALLBACK_STRING__pure(FindNext);
3348
3349 wxString GetProtocol(const wxString& location) {
3350 return wxFileSystemHandler::GetProtocol(location);
3351 }
3352
3353 wxString GetLeftLocation(const wxString& location) {
3354 return wxFileSystemHandler::GetLeftLocation(location);
3355 }
3356
3357 wxString GetAnchor(const wxString& location) {
3358 return wxFileSystemHandler::GetAnchor(location);
3359 }
3360
3361 wxString GetRightLocation(const wxString& location) {
3362 return wxFileSystemHandler::GetRightLocation(location);
3363 }
3364
3365 wxString GetMimeTypeFromExt(const wxString& location) {
3366 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3367 }
3368
3369 PYPRIVATE;
3370 };
3371
3372
3373 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3374 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3375 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3376 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3377
3378
3379 SWIGINTERN int
3380 SWIG_AsVal_bool (PyObject *obj, bool *val)
3381 {
3382 if (obj == Py_True) {
3383 if (val) *val = true;
3384 return SWIG_OK;
3385 } else if (obj == Py_False) {
3386 if (val) *val = false;
3387 return SWIG_OK;
3388 } else {
3389 long v = 0;
3390 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3391 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3392 return res;
3393 }
3394 }
3395
3396 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3397 wxFileName fname = wxFileSystem::URLToFileName(url);
3398 return fname.GetFullPath();
3399 }
3400
3401 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3402 wxImage& image,
3403 long type) {
3404 wxMemoryFSHandler::AddFile(filename, image, type);
3405 }
3406
3407 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3408 const wxBitmap& bitmap,
3409 long type) {
3410 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3411 }
3412
3413 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3414 PyObject* data) {
3415 if (! PyString_Check(data)) {
3416 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3417 "Expected string object"));
3418 return;
3419 }
3420
3421 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3422 void* ptr = (void*)PyString_AsString(data);
3423 size_t size = PyString_Size(data);
3424 wxPyEndBlockThreads(blocked);
3425
3426 wxMemoryFSHandler::AddFile(filename, ptr, size);
3427 }
3428
3429
3430 #include "wx/wxPython/pyistream.h"
3431
3432
3433 SWIGINTERN int
3434 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3435 {
3436 long v = 0;
3437 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3438 return SWIG_TypeError;
3439 }
3440 else if (val)
3441 *val = (unsigned long)v;
3442 return SWIG_OK;
3443 }
3444
3445
3446 SWIGINTERN int
3447 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3448 {
3449 unsigned long v;
3450 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3451 if (SWIG_IsOK(res)) {
3452 if ((v > UCHAR_MAX)) {
3453 return SWIG_OverflowError;
3454 } else {
3455 if (val) *val = static_cast< unsigned char >(v);
3456 }
3457 }
3458 return res;
3459 }
3460
3461
3462 SWIGINTERNINLINE PyObject *
3463 SWIG_From_unsigned_SS_char (unsigned char value)
3464 {
3465 return SWIG_From_unsigned_SS_long (value);
3466 }
3467
3468 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3469 wxImageHistogramEntry e = (*self)[key];
3470 return e.value;
3471 }
3472 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3473 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3474 wxImageHistogramEntry e = (*self)[key];
3475 return e.value;
3476 }
3477 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3478 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3479 colour.Green(),
3480 colour.Blue());
3481 wxImageHistogramEntry e = (*self)[key];
3482 return e.value;
3483 }
3484
3485 typedef unsigned char* buffer;
3486
3487
3488 // Pull the nested class out to the top level for SWIG's sake
3489 #define wxImage_RGBValue wxImage::RGBValue
3490 #define wxImage_HSVValue wxImage::HSVValue
3491
3492 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3493 if (width > 0 && height > 0)
3494 return new wxImage(width, height, clear);
3495 else
3496 return new wxImage;
3497 }
3498 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3499 return new wxImage(bitmap.ConvertToImage());
3500 }
3501 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3502 if (DATASIZE != width*height*3) {
3503 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3504 return NULL;
3505 }
3506
3507 // Copy the source data so the wxImage can clean it up later
3508 buffer copy = (buffer)malloc(DATASIZE);
3509 if (copy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(copy, data, DATASIZE);
3514 return new wxImage(width, height, copy, false);
3515 }
3516 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3517 if (DATASIZE != width*height*3) {
3518 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3519 return NULL;
3520 }
3521 if (ALPHASIZE != width*height) {
3522 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3523 return NULL;
3524 }
3525
3526 // Copy the source data so the wxImage can clean it up later
3527 buffer dcopy = (buffer)malloc(DATASIZE);
3528 if (dcopy == NULL) {
3529 wxPyBLOCK_THREADS(PyErr_NoMemory());
3530 return NULL;
3531 }
3532 memcpy(dcopy, data, DATASIZE);
3533
3534 buffer acopy = (buffer)malloc(ALPHASIZE);
3535 if (acopy == NULL) {
3536 wxPyBLOCK_THREADS(PyErr_NoMemory());
3537 return NULL;
3538 }
3539 memcpy(acopy, alpha, ALPHASIZE);
3540
3541 return new wxImage(width, height, dcopy, acopy, false);
3542 }
3543 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3544 wxSize size(self->GetWidth(), self->GetHeight());
3545 return size;
3546 }
3547 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3548 buffer data = self->GetData();
3549 int len = self->GetWidth() * self->GetHeight() * 3;
3550 PyObject* rv;
3551 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3552 return rv;
3553 }
3554 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3555 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3556 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3557 return;
3558 }
3559 buffer copy = (buffer)malloc(DATASIZE);
3560 if (copy == NULL) {
3561 wxPyBLOCK_THREADS(PyErr_NoMemory());
3562 return;
3563 }
3564 memcpy(copy, data, DATASIZE);
3565 self->SetData(copy, false);
3566 // wxImage takes ownership of copy...
3567 }
3568 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3569 buffer data = self->GetData();
3570 int len = self->GetWidth() * self->GetHeight() * 3;
3571 PyObject* rv;
3572 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3573 return rv;
3574 }
3575 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3576 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3577 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3578 return;
3579 }
3580 self->SetData(data, true);
3581 }
3582 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3583 buffer data = self->GetAlpha();
3584 if (! data) {
3585 RETURN_NONE();
3586 } else {
3587 int len = self->GetWidth() * self->GetHeight();
3588 PyObject* rv;
3589 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3590 return rv;
3591 }
3592 }
3593 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3594 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3596 return;
3597 }
3598 buffer acopy = (buffer)malloc(ALPHASIZE);
3599 if (acopy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(acopy, alpha, ALPHASIZE);
3604 self->SetAlpha(acopy, false);
3605 // wxImage takes ownership of acopy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3608 buffer data = self->GetAlpha();
3609 int len = self->GetWidth() * self->GetHeight();
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3615 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3617 return;
3618 }
3619 self->SetAlpha(alpha, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetHandlers(){
3622 wxList& list = wxImage::GetHandlers();
3623 return wxPy_ConvertList(&list);
3624 }
3625 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3626 wxBitmap bitmap(*self, depth);
3627 return bitmap;
3628 }
3629 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3630 wxImage mono = self->ConvertToMono( red, green, blue );
3631 wxBitmap bitmap( mono, 1 );
3632 return bitmap;
3633 }
3634 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3635 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3636 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3637 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3638 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3639 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3640 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3641 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3642 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3643 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3644 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3645 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3646 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3647 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3648 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3649
3650 #include <wx/quantize.h>
3651
3652 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3653 return wxQuantize::Quantize(src, dest,
3654 //NULL, // palette
3655 desiredNoColours,
3656 NULL, // eightBitData
3657 flags);
3658 }
3659 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3660 if (PyCallable_Check(func)) {
3661 self->Connect(id, lastId, eventType,
3662 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3663 new wxPyCallback(func));
3664 }
3665 else if (func == Py_None) {
3666 self->Disconnect(id, lastId, eventType,
3667 (wxObjectEventFunction)
3668 &wxPyCallback::EventThunker);
3669 }
3670 else {
3671 wxPyBLOCK_THREADS(
3672 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3673 }
3674 }
3675 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3676 return self->Disconnect(id, lastId, eventType,
3677 (wxObjectEventFunction)
3678 &wxPyCallback::EventThunker);
3679 }
3680 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3681 if (_self && _self != Py_None) {
3682 self->SetClientObject(new wxPyOORClientData(_self, incref));
3683 }
3684 else {
3685 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3686 if (data) {
3687 self->SetClientObject(NULL); // This will delete it too
3688 }
3689 }
3690 }
3691
3692 #if ! wxUSE_HOTKEY
3693 #define wxEVT_HOTKEY -9999
3694 #endif
3695
3696 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3697 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3698 if (data) {
3699 Py_INCREF(data->m_obj);
3700 return data->m_obj;
3701 } else {
3702 Py_INCREF(Py_None);
3703 return Py_None;
3704 }
3705 }
3706 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3707 wxPyClientData* data = new wxPyClientData(clientData);
3708 self->SetClientObject(data);
3709 }
3710 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3711 #if wxUSE_UNICODE
3712 return self->GetUnicodeKey();
3713 #else
3714 return 0;
3715 #endif
3716 }
3717 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3718 #if wxUSE_UNICODE
3719 self->m_uniChar = uniChar;
3720 #endif
3721 }
3722
3723 SWIGINTERNINLINE PyObject *
3724 SWIG_From_unsigned_SS_int (unsigned int value)
3725 {
3726 return SWIG_From_unsigned_SS_long (value);
3727 }
3728
3729
3730 SWIGINTERN int
3731 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3732 {
3733 unsigned long v;
3734 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3735 if (SWIG_IsOK(res)) {
3736 if ((v > UINT_MAX)) {
3737 return SWIG_OverflowError;
3738 } else {
3739 if (val) *val = static_cast< unsigned int >(v);
3740 }
3741 }
3742 return res;
3743 }
3744
3745 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3746 self->m_size = size;
3747 }
3748 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3749 int count = self->GetNumberOfFiles();
3750 wxString* files = self->GetFiles();
3751 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3752 PyObject* list = PyList_New(count);
3753
3754 if (!list) {
3755 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3756 wxPyEndBlockThreads(blocked);
3757 return NULL;
3758 }
3759
3760 for (int i=0; i<count; i++) {
3761 PyList_SetItem(list, i, wx2PyString(files[i]));
3762 }
3763 wxPyEndBlockThreads(blocked);
3764 return list;
3765 }
3766
3767
3768 SWIGINTERN wxPyApp *new_wxPyApp(){
3769 wxPythonApp = new wxPyApp();
3770 return wxPythonApp;
3771 }
3772 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3773
3774 void wxApp_CleanUp() {
3775 __wxPyCleanup();
3776 }
3777
3778
3779 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3780
3781
3782
3783
3784
3785 SWIGINTERNINLINE PyObject *
3786 SWIG_FromCharPtr(const char *cptr)
3787 {
3788 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3789 }
3790
3791
3792 #if 0 // #ifdef __WXMAC__
3793
3794 // A dummy class that raises an exception if used...
3795 class wxEventLoop
3796 {
3797 public:
3798 wxEventLoop() { wxPyRaiseNotImplemented(); }
3799 int Run() { return 0; }
3800 void Exit(int rc = 0) {}
3801 bool Pending() const { return false; }
3802 bool Dispatch() { return false; }
3803 bool IsRunning() const { return false; }
3804 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3805 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3806 };
3807
3808 #else
3809
3810 #include <wx/evtloop.h>
3811
3812 #endif
3813
3814
3815
3816 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3817 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3818 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3819 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3820 wxWindowList& list = self->GetChildren();
3821 return wxPy_ConvertList(&list);
3822 }
3823 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3824 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3825 #if wxUSE_HOTKEY
3826 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3827 #else
3828 return false;
3829 #endif
3830 }
3831 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3832
3833
3834
3835 return false;
3836
3837 }
3838 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3839 return wxPyGetWinHandle(self);
3840 }
3841 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3842 self->AssociateHandle((WXWidget)handle);
3843 }
3844 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3845
3846 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3847 return wxWindow::FindWindowById(id, parent);
3848 }
3849
3850 wxWindow* wxFindWindowByName( const wxString& name,
3851 const wxWindow *parent = NULL ) {
3852 return wxWindow::FindWindowByName(name, parent);
3853 }
3854
3855 wxWindow* wxFindWindowByLabel( const wxString& label,
3856 const wxWindow *parent = NULL ) {
3857 return wxWindow::FindWindowByLabel(label, parent);
3858 }
3859
3860
3861 #ifdef __WXMSW__
3862 #include <wx/msw/private.h> // to get wxGetWindowId
3863 #endif
3864
3865
3866 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3867 #ifdef __WXMSW__
3868 WXHWND hWnd = (WXHWND)_hWnd;
3869 long id = wxGetWindowId(hWnd);
3870 wxWindow* win = new wxWindow;
3871 if (parent)
3872 parent->AddChild(win);
3873 win->SetEventHandler(win);
3874 win->SetHWND(hWnd);
3875 win->SetId(id);
3876 win->SubclassWin(hWnd);
3877 win->AdoptAttributesFromHWND();
3878 win->SetupColours();
3879 return win;
3880 #else
3881 wxPyRaiseNotImplemented();
3882 return NULL;
3883 #endif
3884 }
3885
3886
3887 PyObject* GetTopLevelWindows() {
3888 return wxPy_ConvertList(&wxTopLevelWindows);
3889 }
3890
3891
3892 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3893 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3894 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3895
3896 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3897
3898
3899 SWIGINTERNINLINE int
3900 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3901 {
3902 unsigned long v;
3903 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3904 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3905 return res;
3906 }
3907
3908 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3909 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3910 wxMenuItemList& list = self->GetMenuItems();
3911 return wxPy_ConvertList(&list);
3912 }
3913 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3914 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3915 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3916 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3917 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3918 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3919 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3920 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3921 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3922 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3923 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3924 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3925 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3926 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3927 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3928 static const wxString wxPyControlNameStr(wxControlNameStr);
3929 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3930 if (clientData) {
3931 wxPyClientData* data = new wxPyClientData(clientData);
3932 return self->Append(item, data);
3933 } else
3934 return self->Append(item);
3935 }
3936 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3937 if (clientData) {
3938 wxPyClientData* data = new wxPyClientData(clientData);
3939 return self->Insert(item, pos, data);
3940 } else
3941 return self->Insert(item, pos);
3942 }
3943 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3944 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3945 if (data) {
3946 Py_INCREF(data->m_obj);
3947 return data->m_obj;
3948 } else {
3949 Py_INCREF(Py_None);
3950 return Py_None;
3951 }
3952 }
3953 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3954 wxPyClientData* data = new wxPyClientData(clientData);
3955 self->SetClientObject(n, data);
3956 }
3957
3958
3959 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3960 wxPyUserData* data = NULL;
3961 if ( userData ) {
3962 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3963 data = new wxPyUserData(userData);
3964 wxPyEndBlockThreads(blocked);
3965 }
3966 return new wxSizerItem(window, proportion, flag, border, data);
3967 }
3968 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3969 wxPyUserData* data = NULL;
3970 if ( userData ) {
3971 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3972 data = new wxPyUserData(userData);
3973 wxPyEndBlockThreads(blocked);
3974 }
3975 return new wxSizerItem(width, height, proportion, flag, border, data);
3976 }
3977 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3978 wxPyUserData* data = NULL;
3979 if ( userData ) {
3980 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3981 data = new wxPyUserData(userData);
3982 wxPyEndBlockThreads(blocked);
3983 }
3984 return new wxSizerItem(sizer, proportion, flag, border, data);
3985 }
3986
3987 SWIGINTERNINLINE PyObject *
3988 SWIG_From_float (float value)
3989 {
3990 return SWIG_From_double (value);
3991 }
3992
3993 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3994 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3995 if (data) {
3996 Py_INCREF(data->m_obj);
3997 return data->m_obj;
3998 } else {
3999 Py_INCREF(Py_None);
4000 return Py_None;
4001 }
4002 }
4003 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4004 wxPyUserData* data = NULL;
4005 if ( userData ) {
4006 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4007 data = new wxPyUserData(userData);
4008 wxPyEndBlockThreads(blocked);
4009 }
4010 self->SetUserData(data);
4011 }
4012
4013 // Figure out the type of the sizer item
4014
4015 struct wxPySizerItemInfo {
4016 wxPySizerItemInfo()
4017 : window(NULL), sizer(NULL), gotSize(false),
4018 size(wxDefaultSize), gotPos(false), pos(-1)
4019 {}
4020
4021 wxWindow* window;
4022 wxSizer* sizer;
4023 bool gotSize;
4024 wxSize size;
4025 bool gotPos;
4026 int pos;
4027 };
4028
4029 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4030
4031 wxPySizerItemInfo info;
4032 wxSize size;
4033 wxSize* sizePtr = &size;
4034
4035 // Find out what the type of the item is
4036 // try wxWindow
4037 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4038 PyErr_Clear();
4039 info.window = NULL;
4040
4041 // try wxSizer
4042 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4043 PyErr_Clear();
4044 info.sizer = NULL;
4045
4046 // try wxSize or (w,h)
4047 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4048 info.size = *sizePtr;
4049 info.gotSize = true;
4050 }
4051
4052 // or a single int
4053 if (checkIdx && PyInt_Check(item)) {
4054 info.pos = PyInt_AsLong(item);
4055 info.gotPos = true;
4056 }
4057 }
4058 }
4059
4060 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4061 // no expected type, figure out what kind of error message to generate
4062 if ( !checkSize && !checkIdx )
4063 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4064 else if ( checkSize && !checkIdx )
4065 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4066 else if ( !checkSize && checkIdx)
4067 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4068 else
4069 // can this one happen?
4070 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4071 }
4072
4073 return info;
4074 }
4075
4076 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4077 if (!self->GetClientObject())
4078 self->SetClientObject(new wxPyOORClientData(_self));
4079 }
4080 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4081
4082 wxPyUserData* data = NULL;
4083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4084 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4085 if ( userData && (info.window || info.sizer || info.gotSize) )
4086 data = new wxPyUserData(userData);
4087 if ( info.sizer )
4088 PyObject_SetAttrString(item,"thisown",Py_False);
4089 wxPyEndBlockThreads(blocked);
4090
4091 // Now call the real Add method if a valid item type was found
4092 if ( info.window )
4093 return self->Add(info.window, proportion, flag, border, data);
4094 else if ( info.sizer )
4095 return self->Add(info.sizer, proportion, flag, border, data);
4096 else if (info.gotSize)
4097 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4098 proportion, flag, border, data);
4099 else
4100 return NULL;
4101 }
4102 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4103
4104 wxPyUserData* data = NULL;
4105 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4106 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4107 if ( userData && (info.window || info.sizer || info.gotSize) )
4108 data = new wxPyUserData(userData);
4109 if ( info.sizer )
4110 PyObject_SetAttrString(item,"thisown",Py_False);
4111 wxPyEndBlockThreads(blocked);
4112
4113 // Now call the real Insert method if a valid item type was found
4114 if ( info.window )
4115 return self->Insert(before, info.window, proportion, flag, border, data);
4116 else if ( info.sizer )
4117 return self->Insert(before, info.sizer, proportion, flag, border, data);
4118 else if (info.gotSize)
4119 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4120 proportion, flag, border, data);
4121 else
4122 return NULL;
4123 }
4124 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4125
4126 wxPyUserData* data = NULL;
4127 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4128 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4129 if ( userData && (info.window || info.sizer || info.gotSize) )
4130 data = new wxPyUserData(userData);
4131 if ( info.sizer )
4132 PyObject_SetAttrString(item,"thisown",Py_False);
4133 wxPyEndBlockThreads(blocked);
4134
4135 // Now call the real Prepend method if a valid item type was found
4136 if ( info.window )
4137 return self->Prepend(info.window, proportion, flag, border, data);
4138 else if ( info.sizer )
4139 return self->Prepend(info.sizer, proportion, flag, border, data);
4140 else if (info.gotSize)
4141 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4142 proportion, flag, border, data);
4143 else
4144 return NULL;
4145 }
4146 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4147 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4148 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4149 wxPyEndBlockThreads(blocked);
4150 if ( info.window )
4151 return self->Remove(info.window);
4152 else if ( info.sizer )
4153 return self->Remove(info.sizer);
4154 else if ( info.gotPos )
4155 return self->Remove(info.pos);
4156 else
4157 return false;
4158 }
4159 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4161 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4162 wxPyEndBlockThreads(blocked);
4163 if ( info.window )
4164 return self->Detach(info.window);
4165 else if ( info.sizer )
4166 return self->Detach(info.sizer);
4167 else if ( info.gotPos )
4168 return self->Detach(info.pos);
4169 else
4170 return false;
4171 }
4172 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4174 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4175 wxPyEndBlockThreads(blocked);
4176 if ( info.window )
4177 return self->GetItem(info.window);
4178 else if ( info.sizer )
4179 return self->GetItem(info.sizer);
4180 else if ( info.gotPos )
4181 return self->GetItem(info.pos);
4182 else
4183 return NULL;
4184 }
4185 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4187 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4188 wxPyEndBlockThreads(blocked);
4189 if ( info.window )
4190 self->SetItemMinSize(info.window, size);
4191 else if ( info.sizer )
4192 self->SetItemMinSize(info.sizer, size);
4193 else if ( info.gotPos )
4194 self->SetItemMinSize(info.pos, size);
4195 }
4196 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4197 wxSizerItemList& list = self->GetChildren();
4198 return wxPy_ConvertList(&list);
4199 }
4200 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4201 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4202 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4203 wxPyEndBlockThreads(blocked);
4204 if ( info.window )
4205 return self->Show(info.window, show, recursive);
4206 else if ( info.sizer )
4207 return self->Show(info.sizer, show, recursive);
4208 else if ( info.gotPos )
4209 return self->Show(info.pos, show);
4210 else
4211 return false;
4212 }
4213 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4215 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4216 wxPyEndBlockThreads(blocked);
4217 if ( info.window )
4218 return self->IsShown(info.window);
4219 else if ( info.sizer )
4220 return self->IsShown(info.sizer);
4221 else if ( info.gotPos )
4222 return self->IsShown(info.pos);
4223 else
4224 return false;
4225 }
4226
4227 // See pyclasses.h
4228 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4229 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4230 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4231
4232
4233
4234
4235 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4236 {
4237 if (source == Py_None) {
4238 **obj = wxGBPosition(-1,-1);
4239 return true;
4240 }
4241 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4242 }
4243
4244 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4245 {
4246 if (source == Py_None) {
4247 **obj = wxGBSpan(-1,-1);
4248 return true;
4249 }
4250 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4251 }
4252
4253
4254 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4255 wxGBPosition temp, *obj = &temp;
4256 if ( other == Py_None ) return false;
4257 if ( ! wxGBPosition_helper(other, &obj) ) {
4258 PyErr_Clear();
4259 return false;
4260 }
4261 return self->operator==(*obj);
4262 }
4263 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4264 wxGBPosition temp, *obj = &temp;
4265 if ( other == Py_None ) return true;
4266 if ( ! wxGBPosition_helper(other, &obj)) {
4267 PyErr_Clear();
4268 return true;
4269 }
4270 return self->operator!=(*obj);
4271 }
4272 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4273 self->SetRow(row);
4274 self->SetCol(col);
4275 }
4276 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4277 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4278 PyObject* tup = PyTuple_New(2);
4279 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4280 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4281 wxPyEndBlockThreads(blocked);
4282 return tup;
4283 }
4284 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4285 wxGBSpan temp, *obj = &temp;
4286 if ( other == Py_None ) return false;
4287 if ( ! wxGBSpan_helper(other, &obj) ) {
4288 PyErr_Clear();
4289 return false;
4290 }
4291 return self->operator==(*obj);
4292 }
4293 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4294 wxGBSpan temp, *obj = &temp;
4295 if ( other == Py_None ) return true;
4296 if ( ! wxGBSpan_helper(other, &obj)) {
4297 PyErr_Clear();
4298 return true;
4299 }
4300 return self->operator!=(*obj);
4301 }
4302 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4303 self->SetRowspan(rowspan);
4304 self->SetColspan(colspan);
4305 }
4306 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4307 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4308 PyObject* tup = PyTuple_New(2);
4309 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4310 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4311 wxPyEndBlockThreads(blocked);
4312 return tup;
4313 }
4314 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4315 wxPyUserData* data = NULL;
4316 if ( userData ) {
4317 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4318 data = new wxPyUserData(userData);
4319 wxPyEndBlockThreads(blocked);
4320 }
4321 return new wxGBSizerItem(window, pos, span, flag, border, data);
4322 }
4323 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4324 wxPyUserData* data = NULL;
4325 if ( userData ) {
4326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4327 data = new wxPyUserData(userData);
4328 wxPyEndBlockThreads(blocked);
4329 }
4330 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4331 }
4332 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4333 wxPyUserData* data = NULL;
4334 if ( userData ) {
4335 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4336 data = new wxPyUserData(userData);
4337 wxPyEndBlockThreads(blocked);
4338 }
4339 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4340 }
4341 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4342 int row, col;
4343 self->GetEndPos(row, col);
4344 return wxGBPosition(row, col);
4345 }
4346 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4347
4348 wxPyUserData* data = NULL;
4349 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4350 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4351 if ( userData && (info.window || info.sizer || info.gotSize) )
4352 data = new wxPyUserData(userData);
4353 if ( info.sizer )
4354 PyObject_SetAttrString(item,"thisown",Py_False);
4355 wxPyEndBlockThreads(blocked);
4356
4357 // Now call the real Add method if a valid item type was found
4358 if ( info.window )
4359 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4360 else if ( info.sizer )
4361 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4362 else if (info.gotSize)
4363 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4364 pos, span, flag, border, data);
4365 return NULL;
4366 }
4367
4368
4369 #ifdef __cplusplus
4370 extern "C" {
4371 #endif
4372 SWIGINTERN int EmptyString_set(PyObject *) {
4373 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4374 return 1;
4375 }
4376
4377
4378 SWIGINTERN PyObject *EmptyString_get(void) {
4379 PyObject *pyobj = 0;
4380
4381 {
4382 #if wxUSE_UNICODE
4383 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4384 #else
4385 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4386 #endif
4387 }
4388 return pyobj;
4389 }
4390
4391
4392 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4393 PyObject *resultobj = 0;
4394 wxObject *arg1 = (wxObject *) 0 ;
4395 wxString result;
4396 void *argp1 = 0 ;
4397 int res1 = 0 ;
4398 PyObject *swig_obj[1] ;
4399
4400 if (!args) SWIG_fail;
4401 swig_obj[0] = args;
4402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4403 if (!SWIG_IsOK(res1)) {
4404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4405 }
4406 arg1 = reinterpret_cast< wxObject * >(argp1);
4407 {
4408 PyThreadState* __tstate = wxPyBeginAllowThreads();
4409 result = wxObject_GetClassName(arg1);
4410 wxPyEndAllowThreads(__tstate);
4411 if (PyErr_Occurred()) SWIG_fail;
4412 }
4413 {
4414 #if wxUSE_UNICODE
4415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4416 #else
4417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4418 #endif
4419 }
4420 return resultobj;
4421 fail:
4422 return NULL;
4423 }
4424
4425
4426 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4427 PyObject *resultobj = 0;
4428 wxObject *arg1 = (wxObject *) 0 ;
4429 void *argp1 = 0 ;
4430 int res1 = 0 ;
4431 PyObject *swig_obj[1] ;
4432
4433 if (!args) SWIG_fail;
4434 swig_obj[0] = args;
4435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4436 if (!SWIG_IsOK(res1)) {
4437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4438 }
4439 arg1 = reinterpret_cast< wxObject * >(argp1);
4440 {
4441 PyThreadState* __tstate = wxPyBeginAllowThreads();
4442 wxObject_Destroy(arg1);
4443 wxPyEndAllowThreads(__tstate);
4444 if (PyErr_Occurred()) SWIG_fail;
4445 }
4446 resultobj = SWIG_Py_Void();
4447 return resultobj;
4448 fail:
4449 return NULL;
4450 }
4451
4452
4453 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4454 PyObject *obj;
4455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4456 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4457 return SWIG_Py_Void();
4458 }
4459
4460 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4461 PyObject *resultobj = 0;
4462 wxSize *arg1 = (wxSize *) 0 ;
4463 int arg2 ;
4464 void *argp1 = 0 ;
4465 int res1 = 0 ;
4466 int val2 ;
4467 int ecode2 = 0 ;
4468 PyObject *swig_obj[2] ;
4469
4470 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4472 if (!SWIG_IsOK(res1)) {
4473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4474 }
4475 arg1 = reinterpret_cast< wxSize * >(argp1);
4476 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4477 if (!SWIG_IsOK(ecode2)) {
4478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4479 }
4480 arg2 = static_cast< int >(val2);
4481 if (arg1) (arg1)->x = arg2;
4482
4483 resultobj = SWIG_Py_Void();
4484 return resultobj;
4485 fail:
4486 return NULL;
4487 }
4488
4489
4490 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4491 PyObject *resultobj = 0;
4492 wxSize *arg1 = (wxSize *) 0 ;
4493 int result;
4494 void *argp1 = 0 ;
4495 int res1 = 0 ;
4496 PyObject *swig_obj[1] ;
4497
4498 if (!args) SWIG_fail;
4499 swig_obj[0] = args;
4500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4501 if (!SWIG_IsOK(res1)) {
4502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4503 }
4504 arg1 = reinterpret_cast< wxSize * >(argp1);
4505 result = (int) ((arg1)->x);
4506 resultobj = SWIG_From_int(static_cast< int >(result));
4507 return resultobj;
4508 fail:
4509 return NULL;
4510 }
4511
4512
4513 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4514 PyObject *resultobj = 0;
4515 wxSize *arg1 = (wxSize *) 0 ;
4516 int arg2 ;
4517 void *argp1 = 0 ;
4518 int res1 = 0 ;
4519 int val2 ;
4520 int ecode2 = 0 ;
4521 PyObject *swig_obj[2] ;
4522
4523 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4525 if (!SWIG_IsOK(res1)) {
4526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4527 }
4528 arg1 = reinterpret_cast< wxSize * >(argp1);
4529 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4530 if (!SWIG_IsOK(ecode2)) {
4531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4532 }
4533 arg2 = static_cast< int >(val2);
4534 if (arg1) (arg1)->y = arg2;
4535
4536 resultobj = SWIG_Py_Void();
4537 return resultobj;
4538 fail:
4539 return NULL;
4540 }
4541
4542
4543 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4544 PyObject *resultobj = 0;
4545 wxSize *arg1 = (wxSize *) 0 ;
4546 int result;
4547 void *argp1 = 0 ;
4548 int res1 = 0 ;
4549 PyObject *swig_obj[1] ;
4550
4551 if (!args) SWIG_fail;
4552 swig_obj[0] = args;
4553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4554 if (!SWIG_IsOK(res1)) {
4555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4556 }
4557 arg1 = reinterpret_cast< wxSize * >(argp1);
4558 result = (int) ((arg1)->y);
4559 resultobj = SWIG_From_int(static_cast< int >(result));
4560 return resultobj;
4561 fail:
4562 return NULL;
4563 }
4564
4565
4566 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4567 PyObject *resultobj = 0;
4568 int arg1 = (int) 0 ;
4569 int arg2 = (int) 0 ;
4570 wxSize *result = 0 ;
4571 int val1 ;
4572 int ecode1 = 0 ;
4573 int val2 ;
4574 int ecode2 = 0 ;
4575 PyObject * obj0 = 0 ;
4576 PyObject * obj1 = 0 ;
4577 char * kwnames[] = {
4578 (char *) "w",(char *) "h", NULL
4579 };
4580
4581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4582 if (obj0) {
4583 ecode1 = SWIG_AsVal_int(obj0, &val1);
4584 if (!SWIG_IsOK(ecode1)) {
4585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4586 }
4587 arg1 = static_cast< int >(val1);
4588 }
4589 if (obj1) {
4590 ecode2 = SWIG_AsVal_int(obj1, &val2);
4591 if (!SWIG_IsOK(ecode2)) {
4592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4593 }
4594 arg2 = static_cast< int >(val2);
4595 }
4596 {
4597 PyThreadState* __tstate = wxPyBeginAllowThreads();
4598 result = (wxSize *)new wxSize(arg1,arg2);
4599 wxPyEndAllowThreads(__tstate);
4600 if (PyErr_Occurred()) SWIG_fail;
4601 }
4602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4603 return resultobj;
4604 fail:
4605 return NULL;
4606 }
4607
4608
4609 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4610 PyObject *resultobj = 0;
4611 wxSize *arg1 = (wxSize *) 0 ;
4612 void *argp1 = 0 ;
4613 int res1 = 0 ;
4614 PyObject *swig_obj[1] ;
4615
4616 if (!args) SWIG_fail;
4617 swig_obj[0] = args;
4618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4619 if (!SWIG_IsOK(res1)) {
4620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4621 }
4622 arg1 = reinterpret_cast< wxSize * >(argp1);
4623 {
4624 PyThreadState* __tstate = wxPyBeginAllowThreads();
4625 delete arg1;
4626
4627 wxPyEndAllowThreads(__tstate);
4628 if (PyErr_Occurred()) SWIG_fail;
4629 }
4630 resultobj = SWIG_Py_Void();
4631 return resultobj;
4632 fail:
4633 return NULL;
4634 }
4635
4636
4637 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4638 PyObject *resultobj = 0;
4639 wxSize *arg1 = (wxSize *) 0 ;
4640 PyObject *arg2 = (PyObject *) 0 ;
4641 bool result;
4642 void *argp1 = 0 ;
4643 int res1 = 0 ;
4644 PyObject * obj0 = 0 ;
4645 PyObject * obj1 = 0 ;
4646 char * kwnames[] = {
4647 (char *) "self",(char *) "other", NULL
4648 };
4649
4650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4652 if (!SWIG_IsOK(res1)) {
4653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4654 }
4655 arg1 = reinterpret_cast< wxSize * >(argp1);
4656 arg2 = obj1;
4657 {
4658 result = (bool)wxSize___eq__(arg1,arg2);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 {
4662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4663 }
4664 return resultobj;
4665 fail:
4666 return NULL;
4667 }
4668
4669
4670 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4671 PyObject *resultobj = 0;
4672 wxSize *arg1 = (wxSize *) 0 ;
4673 PyObject *arg2 = (PyObject *) 0 ;
4674 bool result;
4675 void *argp1 = 0 ;
4676 int res1 = 0 ;
4677 PyObject * obj0 = 0 ;
4678 PyObject * obj1 = 0 ;
4679 char * kwnames[] = {
4680 (char *) "self",(char *) "other", NULL
4681 };
4682
4683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4685 if (!SWIG_IsOK(res1)) {
4686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4687 }
4688 arg1 = reinterpret_cast< wxSize * >(argp1);
4689 arg2 = obj1;
4690 {
4691 result = (bool)wxSize___ne__(arg1,arg2);
4692 if (PyErr_Occurred()) SWIG_fail;
4693 }
4694 {
4695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4696 }
4697 return resultobj;
4698 fail:
4699 return NULL;
4700 }
4701
4702
4703 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4704 PyObject *resultobj = 0;
4705 wxSize *arg1 = (wxSize *) 0 ;
4706 wxSize *arg2 = 0 ;
4707 wxSize result;
4708 void *argp1 = 0 ;
4709 int res1 = 0 ;
4710 wxSize temp2 ;
4711 PyObject * obj0 = 0 ;
4712 PyObject * obj1 = 0 ;
4713 char * kwnames[] = {
4714 (char *) "self",(char *) "sz", NULL
4715 };
4716
4717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4719 if (!SWIG_IsOK(res1)) {
4720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4721 }
4722 arg1 = reinterpret_cast< wxSize * >(argp1);
4723 {
4724 arg2 = &temp2;
4725 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4726 }
4727 {
4728 PyThreadState* __tstate = wxPyBeginAllowThreads();
4729 result = (arg1)->operator +((wxSize const &)*arg2);
4730 wxPyEndAllowThreads(__tstate);
4731 if (PyErr_Occurred()) SWIG_fail;
4732 }
4733 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4734 return resultobj;
4735 fail:
4736 return NULL;
4737 }
4738
4739
4740 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4741 PyObject *resultobj = 0;
4742 wxSize *arg1 = (wxSize *) 0 ;
4743 wxSize *arg2 = 0 ;
4744 wxSize result;
4745 void *argp1 = 0 ;
4746 int res1 = 0 ;
4747 wxSize temp2 ;
4748 PyObject * obj0 = 0 ;
4749 PyObject * obj1 = 0 ;
4750 char * kwnames[] = {
4751 (char *) "self",(char *) "sz", NULL
4752 };
4753
4754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4756 if (!SWIG_IsOK(res1)) {
4757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4758 }
4759 arg1 = reinterpret_cast< wxSize * >(argp1);
4760 {
4761 arg2 = &temp2;
4762 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4763 }
4764 {
4765 PyThreadState* __tstate = wxPyBeginAllowThreads();
4766 result = (arg1)->operator -((wxSize const &)*arg2);
4767 wxPyEndAllowThreads(__tstate);
4768 if (PyErr_Occurred()) SWIG_fail;
4769 }
4770 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4771 return resultobj;
4772 fail:
4773 return NULL;
4774 }
4775
4776
4777 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4778 PyObject *resultobj = 0;
4779 wxSize *arg1 = (wxSize *) 0 ;
4780 wxSize *arg2 = 0 ;
4781 void *argp1 = 0 ;
4782 int res1 = 0 ;
4783 wxSize temp2 ;
4784 PyObject * obj0 = 0 ;
4785 PyObject * obj1 = 0 ;
4786 char * kwnames[] = {
4787 (char *) "self",(char *) "sz", NULL
4788 };
4789
4790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4792 if (!SWIG_IsOK(res1)) {
4793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4794 }
4795 arg1 = reinterpret_cast< wxSize * >(argp1);
4796 {
4797 arg2 = &temp2;
4798 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4799 }
4800 {
4801 PyThreadState* __tstate = wxPyBeginAllowThreads();
4802 (arg1)->IncTo((wxSize const &)*arg2);
4803 wxPyEndAllowThreads(__tstate);
4804 if (PyErr_Occurred()) SWIG_fail;
4805 }
4806 resultobj = SWIG_Py_Void();
4807 return resultobj;
4808 fail:
4809 return NULL;
4810 }
4811
4812
4813 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4814 PyObject *resultobj = 0;
4815 wxSize *arg1 = (wxSize *) 0 ;
4816 wxSize *arg2 = 0 ;
4817 void *argp1 = 0 ;
4818 int res1 = 0 ;
4819 wxSize temp2 ;
4820 PyObject * obj0 = 0 ;
4821 PyObject * obj1 = 0 ;
4822 char * kwnames[] = {
4823 (char *) "self",(char *) "sz", NULL
4824 };
4825
4826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4828 if (!SWIG_IsOK(res1)) {
4829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4830 }
4831 arg1 = reinterpret_cast< wxSize * >(argp1);
4832 {
4833 arg2 = &temp2;
4834 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4835 }
4836 {
4837 PyThreadState* __tstate = wxPyBeginAllowThreads();
4838 (arg1)->DecTo((wxSize const &)*arg2);
4839 wxPyEndAllowThreads(__tstate);
4840 if (PyErr_Occurred()) SWIG_fail;
4841 }
4842 resultobj = SWIG_Py_Void();
4843 return resultobj;
4844 fail:
4845 return NULL;
4846 }
4847
4848
4849 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4850 PyObject *resultobj = 0;
4851 wxSize *arg1 = (wxSize *) 0 ;
4852 float arg2 ;
4853 float arg3 ;
4854 void *argp1 = 0 ;
4855 int res1 = 0 ;
4856 float val2 ;
4857 int ecode2 = 0 ;
4858 float val3 ;
4859 int ecode3 = 0 ;
4860 PyObject * obj0 = 0 ;
4861 PyObject * obj1 = 0 ;
4862 PyObject * obj2 = 0 ;
4863 char * kwnames[] = {
4864 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4865 };
4866
4867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4869 if (!SWIG_IsOK(res1)) {
4870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4871 }
4872 arg1 = reinterpret_cast< wxSize * >(argp1);
4873 ecode2 = SWIG_AsVal_float(obj1, &val2);
4874 if (!SWIG_IsOK(ecode2)) {
4875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4876 }
4877 arg2 = static_cast< float >(val2);
4878 ecode3 = SWIG_AsVal_float(obj2, &val3);
4879 if (!SWIG_IsOK(ecode3)) {
4880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4881 }
4882 arg3 = static_cast< float >(val3);
4883 {
4884 PyThreadState* __tstate = wxPyBeginAllowThreads();
4885 (arg1)->Scale(arg2,arg3);
4886 wxPyEndAllowThreads(__tstate);
4887 if (PyErr_Occurred()) SWIG_fail;
4888 }
4889 resultobj = SWIG_Py_Void();
4890 return resultobj;
4891 fail:
4892 return NULL;
4893 }
4894
4895
4896 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4897 PyObject *resultobj = 0;
4898 wxSize *arg1 = (wxSize *) 0 ;
4899 int arg2 ;
4900 int arg3 ;
4901 void *argp1 = 0 ;
4902 int res1 = 0 ;
4903 int val2 ;
4904 int ecode2 = 0 ;
4905 int val3 ;
4906 int ecode3 = 0 ;
4907 PyObject * obj0 = 0 ;
4908 PyObject * obj1 = 0 ;
4909 PyObject * obj2 = 0 ;
4910 char * kwnames[] = {
4911 (char *) "self",(char *) "w",(char *) "h", NULL
4912 };
4913
4914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4916 if (!SWIG_IsOK(res1)) {
4917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4918 }
4919 arg1 = reinterpret_cast< wxSize * >(argp1);
4920 ecode2 = SWIG_AsVal_int(obj1, &val2);
4921 if (!SWIG_IsOK(ecode2)) {
4922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4923 }
4924 arg2 = static_cast< int >(val2);
4925 ecode3 = SWIG_AsVal_int(obj2, &val3);
4926 if (!SWIG_IsOK(ecode3)) {
4927 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4928 }
4929 arg3 = static_cast< int >(val3);
4930 {
4931 PyThreadState* __tstate = wxPyBeginAllowThreads();
4932 (arg1)->Set(arg2,arg3);
4933 wxPyEndAllowThreads(__tstate);
4934 if (PyErr_Occurred()) SWIG_fail;
4935 }
4936 resultobj = SWIG_Py_Void();
4937 return resultobj;
4938 fail:
4939 return NULL;
4940 }
4941
4942
4943 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4944 PyObject *resultobj = 0;
4945 wxSize *arg1 = (wxSize *) 0 ;
4946 int arg2 ;
4947 void *argp1 = 0 ;
4948 int res1 = 0 ;
4949 int val2 ;
4950 int ecode2 = 0 ;
4951 PyObject * obj0 = 0 ;
4952 PyObject * obj1 = 0 ;
4953 char * kwnames[] = {
4954 (char *) "self",(char *) "w", NULL
4955 };
4956
4957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4959 if (!SWIG_IsOK(res1)) {
4960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4961 }
4962 arg1 = reinterpret_cast< wxSize * >(argp1);
4963 ecode2 = SWIG_AsVal_int(obj1, &val2);
4964 if (!SWIG_IsOK(ecode2)) {
4965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4966 }
4967 arg2 = static_cast< int >(val2);
4968 {
4969 PyThreadState* __tstate = wxPyBeginAllowThreads();
4970 (arg1)->SetWidth(arg2);
4971 wxPyEndAllowThreads(__tstate);
4972 if (PyErr_Occurred()) SWIG_fail;
4973 }
4974 resultobj = SWIG_Py_Void();
4975 return resultobj;
4976 fail:
4977 return NULL;
4978 }
4979
4980
4981 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4982 PyObject *resultobj = 0;
4983 wxSize *arg1 = (wxSize *) 0 ;
4984 int arg2 ;
4985 void *argp1 = 0 ;
4986 int res1 = 0 ;
4987 int val2 ;
4988 int ecode2 = 0 ;
4989 PyObject * obj0 = 0 ;
4990 PyObject * obj1 = 0 ;
4991 char * kwnames[] = {
4992 (char *) "self",(char *) "h", NULL
4993 };
4994
4995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4997 if (!SWIG_IsOK(res1)) {
4998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4999 }
5000 arg1 = reinterpret_cast< wxSize * >(argp1);
5001 ecode2 = SWIG_AsVal_int(obj1, &val2);
5002 if (!SWIG_IsOK(ecode2)) {
5003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5004 }
5005 arg2 = static_cast< int >(val2);
5006 {
5007 PyThreadState* __tstate = wxPyBeginAllowThreads();
5008 (arg1)->SetHeight(arg2);
5009 wxPyEndAllowThreads(__tstate);
5010 if (PyErr_Occurred()) SWIG_fail;
5011 }
5012 resultobj = SWIG_Py_Void();
5013 return resultobj;
5014 fail:
5015 return NULL;
5016 }
5017
5018
5019 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5020 PyObject *resultobj = 0;
5021 wxSize *arg1 = (wxSize *) 0 ;
5022 int result;
5023 void *argp1 = 0 ;
5024 int res1 = 0 ;
5025 PyObject *swig_obj[1] ;
5026
5027 if (!args) SWIG_fail;
5028 swig_obj[0] = args;
5029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5030 if (!SWIG_IsOK(res1)) {
5031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5032 }
5033 arg1 = reinterpret_cast< wxSize * >(argp1);
5034 {
5035 PyThreadState* __tstate = wxPyBeginAllowThreads();
5036 result = (int)((wxSize const *)arg1)->GetWidth();
5037 wxPyEndAllowThreads(__tstate);
5038 if (PyErr_Occurred()) SWIG_fail;
5039 }
5040 resultobj = SWIG_From_int(static_cast< int >(result));
5041 return resultobj;
5042 fail:
5043 return NULL;
5044 }
5045
5046
5047 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5048 PyObject *resultobj = 0;
5049 wxSize *arg1 = (wxSize *) 0 ;
5050 int result;
5051 void *argp1 = 0 ;
5052 int res1 = 0 ;
5053 PyObject *swig_obj[1] ;
5054
5055 if (!args) SWIG_fail;
5056 swig_obj[0] = args;
5057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5058 if (!SWIG_IsOK(res1)) {
5059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5060 }
5061 arg1 = reinterpret_cast< wxSize * >(argp1);
5062 {
5063 PyThreadState* __tstate = wxPyBeginAllowThreads();
5064 result = (int)((wxSize const *)arg1)->GetHeight();
5065 wxPyEndAllowThreads(__tstate);
5066 if (PyErr_Occurred()) SWIG_fail;
5067 }
5068 resultobj = SWIG_From_int(static_cast< int >(result));
5069 return resultobj;
5070 fail:
5071 return NULL;
5072 }
5073
5074
5075 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5076 PyObject *resultobj = 0;
5077 wxSize *arg1 = (wxSize *) 0 ;
5078 bool result;
5079 void *argp1 = 0 ;
5080 int res1 = 0 ;
5081 PyObject *swig_obj[1] ;
5082
5083 if (!args) SWIG_fail;
5084 swig_obj[0] = args;
5085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5086 if (!SWIG_IsOK(res1)) {
5087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5088 }
5089 arg1 = reinterpret_cast< wxSize * >(argp1);
5090 {
5091 PyThreadState* __tstate = wxPyBeginAllowThreads();
5092 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5093 wxPyEndAllowThreads(__tstate);
5094 if (PyErr_Occurred()) SWIG_fail;
5095 }
5096 {
5097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5098 }
5099 return resultobj;
5100 fail:
5101 return NULL;
5102 }
5103
5104
5105 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5106 PyObject *resultobj = 0;
5107 wxSize *arg1 = (wxSize *) 0 ;
5108 wxSize *arg2 = 0 ;
5109 void *argp1 = 0 ;
5110 int res1 = 0 ;
5111 wxSize temp2 ;
5112 PyObject * obj0 = 0 ;
5113 PyObject * obj1 = 0 ;
5114 char * kwnames[] = {
5115 (char *) "self",(char *) "size", NULL
5116 };
5117
5118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5120 if (!SWIG_IsOK(res1)) {
5121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5122 }
5123 arg1 = reinterpret_cast< wxSize * >(argp1);
5124 {
5125 arg2 = &temp2;
5126 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5127 }
5128 {
5129 PyThreadState* __tstate = wxPyBeginAllowThreads();
5130 (arg1)->SetDefaults((wxSize const &)*arg2);
5131 wxPyEndAllowThreads(__tstate);
5132 if (PyErr_Occurred()) SWIG_fail;
5133 }
5134 resultobj = SWIG_Py_Void();
5135 return resultobj;
5136 fail:
5137 return NULL;
5138 }
5139
5140
5141 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5142 PyObject *resultobj = 0;
5143 wxSize *arg1 = (wxSize *) 0 ;
5144 PyObject *result = 0 ;
5145 void *argp1 = 0 ;
5146 int res1 = 0 ;
5147 PyObject *swig_obj[1] ;
5148
5149 if (!args) SWIG_fail;
5150 swig_obj[0] = args;
5151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5152 if (!SWIG_IsOK(res1)) {
5153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5154 }
5155 arg1 = reinterpret_cast< wxSize * >(argp1);
5156 {
5157 PyThreadState* __tstate = wxPyBeginAllowThreads();
5158 result = (PyObject *)wxSize_Get(arg1);
5159 wxPyEndAllowThreads(__tstate);
5160 if (PyErr_Occurred()) SWIG_fail;
5161 }
5162 resultobj = result;
5163 return resultobj;
5164 fail:
5165 return NULL;
5166 }
5167
5168
5169 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5170 PyObject *obj;
5171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5172 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5173 return SWIG_Py_Void();
5174 }
5175
5176 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5177 return SWIG_Python_InitShadowInstance(args);
5178 }
5179
5180 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5181 PyObject *resultobj = 0;
5182 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5183 double arg2 ;
5184 void *argp1 = 0 ;
5185 int res1 = 0 ;
5186 double val2 ;
5187 int ecode2 = 0 ;
5188 PyObject *swig_obj[2] ;
5189
5190 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5192 if (!SWIG_IsOK(res1)) {
5193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5194 }
5195 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5196 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5197 if (!SWIG_IsOK(ecode2)) {
5198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5199 }
5200 arg2 = static_cast< double >(val2);
5201 if (arg1) (arg1)->x = arg2;
5202
5203 resultobj = SWIG_Py_Void();
5204 return resultobj;
5205 fail:
5206 return NULL;
5207 }
5208
5209
5210 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5211 PyObject *resultobj = 0;
5212 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5213 double result;
5214 void *argp1 = 0 ;
5215 int res1 = 0 ;
5216 PyObject *swig_obj[1] ;
5217
5218 if (!args) SWIG_fail;
5219 swig_obj[0] = args;
5220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5221 if (!SWIG_IsOK(res1)) {
5222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5223 }
5224 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5225 result = (double) ((arg1)->x);
5226 resultobj = SWIG_From_double(static_cast< double >(result));
5227 return resultobj;
5228 fail:
5229 return NULL;
5230 }
5231
5232
5233 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5234 PyObject *resultobj = 0;
5235 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5236 double arg2 ;
5237 void *argp1 = 0 ;
5238 int res1 = 0 ;
5239 double val2 ;
5240 int ecode2 = 0 ;
5241 PyObject *swig_obj[2] ;
5242
5243 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5245 if (!SWIG_IsOK(res1)) {
5246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5247 }
5248 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5249 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5250 if (!SWIG_IsOK(ecode2)) {
5251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5252 }
5253 arg2 = static_cast< double >(val2);
5254 if (arg1) (arg1)->y = arg2;
5255
5256 resultobj = SWIG_Py_Void();
5257 return resultobj;
5258 fail:
5259 return NULL;
5260 }
5261
5262
5263 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5264 PyObject *resultobj = 0;
5265 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5266 double result;
5267 void *argp1 = 0 ;
5268 int res1 = 0 ;
5269 PyObject *swig_obj[1] ;
5270
5271 if (!args) SWIG_fail;
5272 swig_obj[0] = args;
5273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5274 if (!SWIG_IsOK(res1)) {
5275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5276 }
5277 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5278 result = (double) ((arg1)->y);
5279 resultobj = SWIG_From_double(static_cast< double >(result));
5280 return resultobj;
5281 fail:
5282 return NULL;
5283 }
5284
5285
5286 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5287 PyObject *resultobj = 0;
5288 double arg1 = (double) 0.0 ;
5289 double arg2 = (double) 0.0 ;
5290 wxRealPoint *result = 0 ;
5291 double val1 ;
5292 int ecode1 = 0 ;
5293 double val2 ;
5294 int ecode2 = 0 ;
5295 PyObject * obj0 = 0 ;
5296 PyObject * obj1 = 0 ;
5297 char * kwnames[] = {
5298 (char *) "x",(char *) "y", NULL
5299 };
5300
5301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5302 if (obj0) {
5303 ecode1 = SWIG_AsVal_double(obj0, &val1);
5304 if (!SWIG_IsOK(ecode1)) {
5305 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5306 }
5307 arg1 = static_cast< double >(val1);
5308 }
5309 if (obj1) {
5310 ecode2 = SWIG_AsVal_double(obj1, &val2);
5311 if (!SWIG_IsOK(ecode2)) {
5312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5313 }
5314 arg2 = static_cast< double >(val2);
5315 }
5316 {
5317 PyThreadState* __tstate = wxPyBeginAllowThreads();
5318 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5319 wxPyEndAllowThreads(__tstate);
5320 if (PyErr_Occurred()) SWIG_fail;
5321 }
5322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5323 return resultobj;
5324 fail:
5325 return NULL;
5326 }
5327
5328
5329 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5330 PyObject *resultobj = 0;
5331 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5332 void *argp1 = 0 ;
5333 int res1 = 0 ;
5334 PyObject *swig_obj[1] ;
5335
5336 if (!args) SWIG_fail;
5337 swig_obj[0] = args;
5338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5339 if (!SWIG_IsOK(res1)) {
5340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5341 }
5342 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5343 {
5344 PyThreadState* __tstate = wxPyBeginAllowThreads();
5345 delete arg1;
5346
5347 wxPyEndAllowThreads(__tstate);
5348 if (PyErr_Occurred()) SWIG_fail;
5349 }
5350 resultobj = SWIG_Py_Void();
5351 return resultobj;
5352 fail:
5353 return NULL;
5354 }
5355
5356
5357 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5358 PyObject *resultobj = 0;
5359 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5360 PyObject *arg2 = (PyObject *) 0 ;
5361 bool result;
5362 void *argp1 = 0 ;
5363 int res1 = 0 ;
5364 PyObject * obj0 = 0 ;
5365 PyObject * obj1 = 0 ;
5366 char * kwnames[] = {
5367 (char *) "self",(char *) "other", NULL
5368 };
5369
5370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5372 if (!SWIG_IsOK(res1)) {
5373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5374 }
5375 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5376 arg2 = obj1;
5377 {
5378 result = (bool)wxRealPoint___eq__(arg1,arg2);
5379 if (PyErr_Occurred()) SWIG_fail;
5380 }
5381 {
5382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5383 }
5384 return resultobj;
5385 fail:
5386 return NULL;
5387 }
5388
5389
5390 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5391 PyObject *resultobj = 0;
5392 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5393 PyObject *arg2 = (PyObject *) 0 ;
5394 bool result;
5395 void *argp1 = 0 ;
5396 int res1 = 0 ;
5397 PyObject * obj0 = 0 ;
5398 PyObject * obj1 = 0 ;
5399 char * kwnames[] = {
5400 (char *) "self",(char *) "other", NULL
5401 };
5402
5403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5405 if (!SWIG_IsOK(res1)) {
5406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5407 }
5408 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5409 arg2 = obj1;
5410 {
5411 result = (bool)wxRealPoint___ne__(arg1,arg2);
5412 if (PyErr_Occurred()) SWIG_fail;
5413 }
5414 {
5415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5416 }
5417 return resultobj;
5418 fail:
5419 return NULL;
5420 }
5421
5422
5423 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5424 PyObject *resultobj = 0;
5425 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5426 wxRealPoint *arg2 = 0 ;
5427 wxRealPoint result;
5428 void *argp1 = 0 ;
5429 int res1 = 0 ;
5430 wxRealPoint temp2 ;
5431 PyObject * obj0 = 0 ;
5432 PyObject * obj1 = 0 ;
5433 char * kwnames[] = {
5434 (char *) "self",(char *) "pt", NULL
5435 };
5436
5437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5439 if (!SWIG_IsOK(res1)) {
5440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5441 }
5442 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5443 {
5444 arg2 = &temp2;
5445 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5446 }
5447 {
5448 PyThreadState* __tstate = wxPyBeginAllowThreads();
5449 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5450 wxPyEndAllowThreads(__tstate);
5451 if (PyErr_Occurred()) SWIG_fail;
5452 }
5453 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5454 return resultobj;
5455 fail:
5456 return NULL;
5457 }
5458
5459
5460 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5461 PyObject *resultobj = 0;
5462 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5463 wxRealPoint *arg2 = 0 ;
5464 wxRealPoint result;
5465 void *argp1 = 0 ;
5466 int res1 = 0 ;
5467 wxRealPoint temp2 ;
5468 PyObject * obj0 = 0 ;
5469 PyObject * obj1 = 0 ;
5470 char * kwnames[] = {
5471 (char *) "self",(char *) "pt", NULL
5472 };
5473
5474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5476 if (!SWIG_IsOK(res1)) {
5477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5478 }
5479 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5480 {
5481 arg2 = &temp2;
5482 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5483 }
5484 {
5485 PyThreadState* __tstate = wxPyBeginAllowThreads();
5486 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5487 wxPyEndAllowThreads(__tstate);
5488 if (PyErr_Occurred()) SWIG_fail;
5489 }
5490 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5491 return resultobj;
5492 fail:
5493 return NULL;
5494 }
5495
5496
5497 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5498 PyObject *resultobj = 0;
5499 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5500 double arg2 ;
5501 double arg3 ;
5502 void *argp1 = 0 ;
5503 int res1 = 0 ;
5504 double val2 ;
5505 int ecode2 = 0 ;
5506 double val3 ;
5507 int ecode3 = 0 ;
5508 PyObject * obj0 = 0 ;
5509 PyObject * obj1 = 0 ;
5510 PyObject * obj2 = 0 ;
5511 char * kwnames[] = {
5512 (char *) "self",(char *) "x",(char *) "y", NULL
5513 };
5514
5515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5517 if (!SWIG_IsOK(res1)) {
5518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5519 }
5520 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5521 ecode2 = SWIG_AsVal_double(obj1, &val2);
5522 if (!SWIG_IsOK(ecode2)) {
5523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5524 }
5525 arg2 = static_cast< double >(val2);
5526 ecode3 = SWIG_AsVal_double(obj2, &val3);
5527 if (!SWIG_IsOK(ecode3)) {
5528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5529 }
5530 arg3 = static_cast< double >(val3);
5531 {
5532 PyThreadState* __tstate = wxPyBeginAllowThreads();
5533 wxRealPoint_Set(arg1,arg2,arg3);
5534 wxPyEndAllowThreads(__tstate);
5535 if (PyErr_Occurred()) SWIG_fail;
5536 }
5537 resultobj = SWIG_Py_Void();
5538 return resultobj;
5539 fail:
5540 return NULL;
5541 }
5542
5543
5544 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5545 PyObject *resultobj = 0;
5546 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5547 PyObject *result = 0 ;
5548 void *argp1 = 0 ;
5549 int res1 = 0 ;
5550 PyObject *swig_obj[1] ;
5551
5552 if (!args) SWIG_fail;
5553 swig_obj[0] = args;
5554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5555 if (!SWIG_IsOK(res1)) {
5556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5557 }
5558 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5559 {
5560 PyThreadState* __tstate = wxPyBeginAllowThreads();
5561 result = (PyObject *)wxRealPoint_Get(arg1);
5562 wxPyEndAllowThreads(__tstate);
5563 if (PyErr_Occurred()) SWIG_fail;
5564 }
5565 resultobj = result;
5566 return resultobj;
5567 fail:
5568 return NULL;
5569 }
5570
5571
5572 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5573 PyObject *obj;
5574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5575 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5576 return SWIG_Py_Void();
5577 }
5578
5579 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5580 return SWIG_Python_InitShadowInstance(args);
5581 }
5582
5583 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5584 PyObject *resultobj = 0;
5585 wxPoint *arg1 = (wxPoint *) 0 ;
5586 int arg2 ;
5587 void *argp1 = 0 ;
5588 int res1 = 0 ;
5589 int val2 ;
5590 int ecode2 = 0 ;
5591 PyObject *swig_obj[2] ;
5592
5593 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5595 if (!SWIG_IsOK(res1)) {
5596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5597 }
5598 arg1 = reinterpret_cast< wxPoint * >(argp1);
5599 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5600 if (!SWIG_IsOK(ecode2)) {
5601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5602 }
5603 arg2 = static_cast< int >(val2);
5604 if (arg1) (arg1)->x = arg2;
5605
5606 resultobj = SWIG_Py_Void();
5607 return resultobj;
5608 fail:
5609 return NULL;
5610 }
5611
5612
5613 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5614 PyObject *resultobj = 0;
5615 wxPoint *arg1 = (wxPoint *) 0 ;
5616 int result;
5617 void *argp1 = 0 ;
5618 int res1 = 0 ;
5619 PyObject *swig_obj[1] ;
5620
5621 if (!args) SWIG_fail;
5622 swig_obj[0] = args;
5623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5624 if (!SWIG_IsOK(res1)) {
5625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5626 }
5627 arg1 = reinterpret_cast< wxPoint * >(argp1);
5628 result = (int) ((arg1)->x);
5629 resultobj = SWIG_From_int(static_cast< int >(result));
5630 return resultobj;
5631 fail:
5632 return NULL;
5633 }
5634
5635
5636 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5637 PyObject *resultobj = 0;
5638 wxPoint *arg1 = (wxPoint *) 0 ;
5639 int arg2 ;
5640 void *argp1 = 0 ;
5641 int res1 = 0 ;
5642 int val2 ;
5643 int ecode2 = 0 ;
5644 PyObject *swig_obj[2] ;
5645
5646 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5648 if (!SWIG_IsOK(res1)) {
5649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5650 }
5651 arg1 = reinterpret_cast< wxPoint * >(argp1);
5652 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5653 if (!SWIG_IsOK(ecode2)) {
5654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5655 }
5656 arg2 = static_cast< int >(val2);
5657 if (arg1) (arg1)->y = arg2;
5658
5659 resultobj = SWIG_Py_Void();
5660 return resultobj;
5661 fail:
5662 return NULL;
5663 }
5664
5665
5666 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5667 PyObject *resultobj = 0;
5668 wxPoint *arg1 = (wxPoint *) 0 ;
5669 int result;
5670 void *argp1 = 0 ;
5671 int res1 = 0 ;
5672 PyObject *swig_obj[1] ;
5673
5674 if (!args) SWIG_fail;
5675 swig_obj[0] = args;
5676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5677 if (!SWIG_IsOK(res1)) {
5678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5679 }
5680 arg1 = reinterpret_cast< wxPoint * >(argp1);
5681 result = (int) ((arg1)->y);
5682 resultobj = SWIG_From_int(static_cast< int >(result));
5683 return resultobj;
5684 fail:
5685 return NULL;
5686 }
5687
5688
5689 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5690 PyObject *resultobj = 0;
5691 int arg1 = (int) 0 ;
5692 int arg2 = (int) 0 ;
5693 wxPoint *result = 0 ;
5694 int val1 ;
5695 int ecode1 = 0 ;
5696 int val2 ;
5697 int ecode2 = 0 ;
5698 PyObject * obj0 = 0 ;
5699 PyObject * obj1 = 0 ;
5700 char * kwnames[] = {
5701 (char *) "x",(char *) "y", NULL
5702 };
5703
5704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5705 if (obj0) {
5706 ecode1 = SWIG_AsVal_int(obj0, &val1);
5707 if (!SWIG_IsOK(ecode1)) {
5708 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5709 }
5710 arg1 = static_cast< int >(val1);
5711 }
5712 if (obj1) {
5713 ecode2 = SWIG_AsVal_int(obj1, &val2);
5714 if (!SWIG_IsOK(ecode2)) {
5715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5716 }
5717 arg2 = static_cast< int >(val2);
5718 }
5719 {
5720 PyThreadState* __tstate = wxPyBeginAllowThreads();
5721 result = (wxPoint *)new wxPoint(arg1,arg2);
5722 wxPyEndAllowThreads(__tstate);
5723 if (PyErr_Occurred()) SWIG_fail;
5724 }
5725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5726 return resultobj;
5727 fail:
5728 return NULL;
5729 }
5730
5731
5732 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5733 PyObject *resultobj = 0;
5734 wxPoint *arg1 = (wxPoint *) 0 ;
5735 void *argp1 = 0 ;
5736 int res1 = 0 ;
5737 PyObject *swig_obj[1] ;
5738
5739 if (!args) SWIG_fail;
5740 swig_obj[0] = args;
5741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5742 if (!SWIG_IsOK(res1)) {
5743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5744 }
5745 arg1 = reinterpret_cast< wxPoint * >(argp1);
5746 {
5747 PyThreadState* __tstate = wxPyBeginAllowThreads();
5748 delete arg1;
5749
5750 wxPyEndAllowThreads(__tstate);
5751 if (PyErr_Occurred()) SWIG_fail;
5752 }
5753 resultobj = SWIG_Py_Void();
5754 return resultobj;
5755 fail:
5756 return NULL;
5757 }
5758
5759
5760 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5761 PyObject *resultobj = 0;
5762 wxPoint *arg1 = (wxPoint *) 0 ;
5763 PyObject *arg2 = (PyObject *) 0 ;
5764 bool result;
5765 void *argp1 = 0 ;
5766 int res1 = 0 ;
5767 PyObject * obj0 = 0 ;
5768 PyObject * obj1 = 0 ;
5769 char * kwnames[] = {
5770 (char *) "self",(char *) "other", NULL
5771 };
5772
5773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5775 if (!SWIG_IsOK(res1)) {
5776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5777 }
5778 arg1 = reinterpret_cast< wxPoint * >(argp1);
5779 arg2 = obj1;
5780 {
5781 result = (bool)wxPoint___eq__(arg1,arg2);
5782 if (PyErr_Occurred()) SWIG_fail;
5783 }
5784 {
5785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5786 }
5787 return resultobj;
5788 fail:
5789 return NULL;
5790 }
5791
5792
5793 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5794 PyObject *resultobj = 0;
5795 wxPoint *arg1 = (wxPoint *) 0 ;
5796 PyObject *arg2 = (PyObject *) 0 ;
5797 bool result;
5798 void *argp1 = 0 ;
5799 int res1 = 0 ;
5800 PyObject * obj0 = 0 ;
5801 PyObject * obj1 = 0 ;
5802 char * kwnames[] = {
5803 (char *) "self",(char *) "other", NULL
5804 };
5805
5806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5808 if (!SWIG_IsOK(res1)) {
5809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5810 }
5811 arg1 = reinterpret_cast< wxPoint * >(argp1);
5812 arg2 = obj1;
5813 {
5814 result = (bool)wxPoint___ne__(arg1,arg2);
5815 if (PyErr_Occurred()) SWIG_fail;
5816 }
5817 {
5818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5819 }
5820 return resultobj;
5821 fail:
5822 return NULL;
5823 }
5824
5825
5826 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5827 PyObject *resultobj = 0;
5828 wxPoint *arg1 = (wxPoint *) 0 ;
5829 wxPoint *arg2 = 0 ;
5830 wxPoint result;
5831 void *argp1 = 0 ;
5832 int res1 = 0 ;
5833 wxPoint temp2 ;
5834 PyObject * obj0 = 0 ;
5835 PyObject * obj1 = 0 ;
5836 char * kwnames[] = {
5837 (char *) "self",(char *) "pt", NULL
5838 };
5839
5840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5842 if (!SWIG_IsOK(res1)) {
5843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5844 }
5845 arg1 = reinterpret_cast< wxPoint * >(argp1);
5846 {
5847 arg2 = &temp2;
5848 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5849 }
5850 {
5851 PyThreadState* __tstate = wxPyBeginAllowThreads();
5852 result = (arg1)->operator +((wxPoint const &)*arg2);
5853 wxPyEndAllowThreads(__tstate);
5854 if (PyErr_Occurred()) SWIG_fail;
5855 }
5856 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5857 return resultobj;
5858 fail:
5859 return NULL;
5860 }
5861
5862
5863 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5864 PyObject *resultobj = 0;
5865 wxPoint *arg1 = (wxPoint *) 0 ;
5866 wxPoint *arg2 = 0 ;
5867 wxPoint result;
5868 void *argp1 = 0 ;
5869 int res1 = 0 ;
5870 wxPoint temp2 ;
5871 PyObject * obj0 = 0 ;
5872 PyObject * obj1 = 0 ;
5873 char * kwnames[] = {
5874 (char *) "self",(char *) "pt", NULL
5875 };
5876
5877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5879 if (!SWIG_IsOK(res1)) {
5880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5881 }
5882 arg1 = reinterpret_cast< wxPoint * >(argp1);
5883 {
5884 arg2 = &temp2;
5885 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5886 }
5887 {
5888 PyThreadState* __tstate = wxPyBeginAllowThreads();
5889 result = (arg1)->operator -((wxPoint const &)*arg2);
5890 wxPyEndAllowThreads(__tstate);
5891 if (PyErr_Occurred()) SWIG_fail;
5892 }
5893 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5894 return resultobj;
5895 fail:
5896 return NULL;
5897 }
5898
5899
5900 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5901 PyObject *resultobj = 0;
5902 wxPoint *arg1 = (wxPoint *) 0 ;
5903 wxPoint *arg2 = 0 ;
5904 wxPoint *result = 0 ;
5905 void *argp1 = 0 ;
5906 int res1 = 0 ;
5907 wxPoint temp2 ;
5908 PyObject * obj0 = 0 ;
5909 PyObject * obj1 = 0 ;
5910 char * kwnames[] = {
5911 (char *) "self",(char *) "pt", NULL
5912 };
5913
5914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5916 if (!SWIG_IsOK(res1)) {
5917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5918 }
5919 arg1 = reinterpret_cast< wxPoint * >(argp1);
5920 {
5921 arg2 = &temp2;
5922 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5923 }
5924 {
5925 PyThreadState* __tstate = wxPyBeginAllowThreads();
5926 {
5927 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5928 result = (wxPoint *) &_result_ref;
5929 }
5930 wxPyEndAllowThreads(__tstate);
5931 if (PyErr_Occurred()) SWIG_fail;
5932 }
5933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5934 return resultobj;
5935 fail:
5936 return NULL;
5937 }
5938
5939
5940 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5941 PyObject *resultobj = 0;
5942 wxPoint *arg1 = (wxPoint *) 0 ;
5943 wxPoint *arg2 = 0 ;
5944 wxPoint *result = 0 ;
5945 void *argp1 = 0 ;
5946 int res1 = 0 ;
5947 wxPoint temp2 ;
5948 PyObject * obj0 = 0 ;
5949 PyObject * obj1 = 0 ;
5950 char * kwnames[] = {
5951 (char *) "self",(char *) "pt", NULL
5952 };
5953
5954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5956 if (!SWIG_IsOK(res1)) {
5957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5958 }
5959 arg1 = reinterpret_cast< wxPoint * >(argp1);
5960 {
5961 arg2 = &temp2;
5962 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5963 }
5964 {
5965 PyThreadState* __tstate = wxPyBeginAllowThreads();
5966 {
5967 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5968 result = (wxPoint *) &_result_ref;
5969 }
5970 wxPyEndAllowThreads(__tstate);
5971 if (PyErr_Occurred()) SWIG_fail;
5972 }
5973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5974 return resultobj;
5975 fail:
5976 return NULL;
5977 }
5978
5979
5980 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5981 PyObject *resultobj = 0;
5982 wxPoint *arg1 = (wxPoint *) 0 ;
5983 long arg2 ;
5984 long arg3 ;
5985 void *argp1 = 0 ;
5986 int res1 = 0 ;
5987 long val2 ;
5988 int ecode2 = 0 ;
5989 long val3 ;
5990 int ecode3 = 0 ;
5991 PyObject * obj0 = 0 ;
5992 PyObject * obj1 = 0 ;
5993 PyObject * obj2 = 0 ;
5994 char * kwnames[] = {
5995 (char *) "self",(char *) "x",(char *) "y", NULL
5996 };
5997
5998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6000 if (!SWIG_IsOK(res1)) {
6001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6002 }
6003 arg1 = reinterpret_cast< wxPoint * >(argp1);
6004 ecode2 = SWIG_AsVal_long(obj1, &val2);
6005 if (!SWIG_IsOK(ecode2)) {
6006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6007 }
6008 arg2 = static_cast< long >(val2);
6009 ecode3 = SWIG_AsVal_long(obj2, &val3);
6010 if (!SWIG_IsOK(ecode3)) {
6011 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6012 }
6013 arg3 = static_cast< long >(val3);
6014 {
6015 PyThreadState* __tstate = wxPyBeginAllowThreads();
6016 wxPoint_Set(arg1,arg2,arg3);
6017 wxPyEndAllowThreads(__tstate);
6018 if (PyErr_Occurred()) SWIG_fail;
6019 }
6020 resultobj = SWIG_Py_Void();
6021 return resultobj;
6022 fail:
6023 return NULL;
6024 }
6025
6026
6027 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6028 PyObject *resultobj = 0;
6029 wxPoint *arg1 = (wxPoint *) 0 ;
6030 PyObject *result = 0 ;
6031 void *argp1 = 0 ;
6032 int res1 = 0 ;
6033 PyObject *swig_obj[1] ;
6034
6035 if (!args) SWIG_fail;
6036 swig_obj[0] = args;
6037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6038 if (!SWIG_IsOK(res1)) {
6039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6040 }
6041 arg1 = reinterpret_cast< wxPoint * >(argp1);
6042 {
6043 PyThreadState* __tstate = wxPyBeginAllowThreads();
6044 result = (PyObject *)wxPoint_Get(arg1);
6045 wxPyEndAllowThreads(__tstate);
6046 if (PyErr_Occurred()) SWIG_fail;
6047 }
6048 resultobj = result;
6049 return resultobj;
6050 fail:
6051 return NULL;
6052 }
6053
6054
6055 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6056 PyObject *obj;
6057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6058 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6059 return SWIG_Py_Void();
6060 }
6061
6062 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6063 return SWIG_Python_InitShadowInstance(args);
6064 }
6065
6066 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6067 PyObject *resultobj = 0;
6068 int arg1 = (int) 0 ;
6069 int arg2 = (int) 0 ;
6070 int arg3 = (int) 0 ;
6071 int arg4 = (int) 0 ;
6072 wxRect *result = 0 ;
6073 int val1 ;
6074 int ecode1 = 0 ;
6075 int val2 ;
6076 int ecode2 = 0 ;
6077 int val3 ;
6078 int ecode3 = 0 ;
6079 int val4 ;
6080 int ecode4 = 0 ;
6081 PyObject * obj0 = 0 ;
6082 PyObject * obj1 = 0 ;
6083 PyObject * obj2 = 0 ;
6084 PyObject * obj3 = 0 ;
6085 char * kwnames[] = {
6086 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6087 };
6088
6089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6090 if (obj0) {
6091 ecode1 = SWIG_AsVal_int(obj0, &val1);
6092 if (!SWIG_IsOK(ecode1)) {
6093 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6094 }
6095 arg1 = static_cast< int >(val1);
6096 }
6097 if (obj1) {
6098 ecode2 = SWIG_AsVal_int(obj1, &val2);
6099 if (!SWIG_IsOK(ecode2)) {
6100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6101 }
6102 arg2 = static_cast< int >(val2);
6103 }
6104 if (obj2) {
6105 ecode3 = SWIG_AsVal_int(obj2, &val3);
6106 if (!SWIG_IsOK(ecode3)) {
6107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6108 }
6109 arg3 = static_cast< int >(val3);
6110 }
6111 if (obj3) {
6112 ecode4 = SWIG_AsVal_int(obj3, &val4);
6113 if (!SWIG_IsOK(ecode4)) {
6114 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6115 }
6116 arg4 = static_cast< int >(val4);
6117 }
6118 {
6119 PyThreadState* __tstate = wxPyBeginAllowThreads();
6120 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6121 wxPyEndAllowThreads(__tstate);
6122 if (PyErr_Occurred()) SWIG_fail;
6123 }
6124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6125 return resultobj;
6126 fail:
6127 return NULL;
6128 }
6129
6130
6131 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6132 PyObject *resultobj = 0;
6133 wxPoint *arg1 = 0 ;
6134 wxPoint *arg2 = 0 ;
6135 wxRect *result = 0 ;
6136 wxPoint temp1 ;
6137 wxPoint temp2 ;
6138 PyObject * obj0 = 0 ;
6139 PyObject * obj1 = 0 ;
6140 char * kwnames[] = {
6141 (char *) "topLeft",(char *) "bottomRight", NULL
6142 };
6143
6144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6145 {
6146 arg1 = &temp1;
6147 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6148 }
6149 {
6150 arg2 = &temp2;
6151 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6152 }
6153 {
6154 PyThreadState* __tstate = wxPyBeginAllowThreads();
6155 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6156 wxPyEndAllowThreads(__tstate);
6157 if (PyErr_Occurred()) SWIG_fail;
6158 }
6159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6160 return resultobj;
6161 fail:
6162 return NULL;
6163 }
6164
6165
6166 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6167 PyObject *resultobj = 0;
6168 wxPoint *arg1 = 0 ;
6169 wxSize *arg2 = 0 ;
6170 wxRect *result = 0 ;
6171 wxPoint temp1 ;
6172 wxSize temp2 ;
6173 PyObject * obj0 = 0 ;
6174 PyObject * obj1 = 0 ;
6175 char * kwnames[] = {
6176 (char *) "pos",(char *) "size", NULL
6177 };
6178
6179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6180 {
6181 arg1 = &temp1;
6182 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6183 }
6184 {
6185 arg2 = &temp2;
6186 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6187 }
6188 {
6189 PyThreadState* __tstate = wxPyBeginAllowThreads();
6190 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6191 wxPyEndAllowThreads(__tstate);
6192 if (PyErr_Occurred()) SWIG_fail;
6193 }
6194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6195 return resultobj;
6196 fail:
6197 return NULL;
6198 }
6199
6200
6201 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6202 PyObject *resultobj = 0;
6203 wxSize *arg1 = 0 ;
6204 wxRect *result = 0 ;
6205 wxSize temp1 ;
6206 PyObject * obj0 = 0 ;
6207 char * kwnames[] = {
6208 (char *) "size", NULL
6209 };
6210
6211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6212 {
6213 arg1 = &temp1;
6214 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6215 }
6216 {
6217 PyThreadState* __tstate = wxPyBeginAllowThreads();
6218 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6219 wxPyEndAllowThreads(__tstate);
6220 if (PyErr_Occurred()) SWIG_fail;
6221 }
6222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6223 return resultobj;
6224 fail:
6225 return NULL;
6226 }
6227
6228
6229 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6230 PyObject *resultobj = 0;
6231 wxRect *arg1 = (wxRect *) 0 ;
6232 void *argp1 = 0 ;
6233 int res1 = 0 ;
6234 PyObject *swig_obj[1] ;
6235
6236 if (!args) SWIG_fail;
6237 swig_obj[0] = args;
6238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6239 if (!SWIG_IsOK(res1)) {
6240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6241 }
6242 arg1 = reinterpret_cast< wxRect * >(argp1);
6243 {
6244 PyThreadState* __tstate = wxPyBeginAllowThreads();
6245 delete arg1;
6246
6247 wxPyEndAllowThreads(__tstate);
6248 if (PyErr_Occurred()) SWIG_fail;
6249 }
6250 resultobj = SWIG_Py_Void();
6251 return resultobj;
6252 fail:
6253 return NULL;
6254 }
6255
6256
6257 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6258 PyObject *resultobj = 0;
6259 wxRect *arg1 = (wxRect *) 0 ;
6260 int result;
6261 void *argp1 = 0 ;
6262 int res1 = 0 ;
6263 PyObject *swig_obj[1] ;
6264
6265 if (!args) SWIG_fail;
6266 swig_obj[0] = args;
6267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6268 if (!SWIG_IsOK(res1)) {
6269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6270 }
6271 arg1 = reinterpret_cast< wxRect * >(argp1);
6272 {
6273 PyThreadState* __tstate = wxPyBeginAllowThreads();
6274 result = (int)((wxRect const *)arg1)->GetX();
6275 wxPyEndAllowThreads(__tstate);
6276 if (PyErr_Occurred()) SWIG_fail;
6277 }
6278 resultobj = SWIG_From_int(static_cast< int >(result));
6279 return resultobj;
6280 fail:
6281 return NULL;
6282 }
6283
6284
6285 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6286 PyObject *resultobj = 0;
6287 wxRect *arg1 = (wxRect *) 0 ;
6288 int arg2 ;
6289 void *argp1 = 0 ;
6290 int res1 = 0 ;
6291 int val2 ;
6292 int ecode2 = 0 ;
6293 PyObject * obj0 = 0 ;
6294 PyObject * obj1 = 0 ;
6295 char * kwnames[] = {
6296 (char *) "self",(char *) "x", NULL
6297 };
6298
6299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6301 if (!SWIG_IsOK(res1)) {
6302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6303 }
6304 arg1 = reinterpret_cast< wxRect * >(argp1);
6305 ecode2 = SWIG_AsVal_int(obj1, &val2);
6306 if (!SWIG_IsOK(ecode2)) {
6307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6308 }
6309 arg2 = static_cast< int >(val2);
6310 {
6311 PyThreadState* __tstate = wxPyBeginAllowThreads();
6312 (arg1)->SetX(arg2);
6313 wxPyEndAllowThreads(__tstate);
6314 if (PyErr_Occurred()) SWIG_fail;
6315 }
6316 resultobj = SWIG_Py_Void();
6317 return resultobj;
6318 fail:
6319 return NULL;
6320 }
6321
6322
6323 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6324 PyObject *resultobj = 0;
6325 wxRect *arg1 = (wxRect *) 0 ;
6326 int result;
6327 void *argp1 = 0 ;
6328 int res1 = 0 ;
6329 PyObject *swig_obj[1] ;
6330
6331 if (!args) SWIG_fail;
6332 swig_obj[0] = args;
6333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6334 if (!SWIG_IsOK(res1)) {
6335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6336 }
6337 arg1 = reinterpret_cast< wxRect * >(argp1);
6338 {
6339 PyThreadState* __tstate = wxPyBeginAllowThreads();
6340 result = (int)(arg1)->GetY();
6341 wxPyEndAllowThreads(__tstate);
6342 if (PyErr_Occurred()) SWIG_fail;
6343 }
6344 resultobj = SWIG_From_int(static_cast< int >(result));
6345 return resultobj;
6346 fail:
6347 return NULL;
6348 }
6349
6350
6351 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6352 PyObject *resultobj = 0;
6353 wxRect *arg1 = (wxRect *) 0 ;
6354 int arg2 ;
6355 void *argp1 = 0 ;
6356 int res1 = 0 ;
6357 int val2 ;
6358 int ecode2 = 0 ;
6359 PyObject * obj0 = 0 ;
6360 PyObject * obj1 = 0 ;
6361 char * kwnames[] = {
6362 (char *) "self",(char *) "y", NULL
6363 };
6364
6365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6367 if (!SWIG_IsOK(res1)) {
6368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6369 }
6370 arg1 = reinterpret_cast< wxRect * >(argp1);
6371 ecode2 = SWIG_AsVal_int(obj1, &val2);
6372 if (!SWIG_IsOK(ecode2)) {
6373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6374 }
6375 arg2 = static_cast< int >(val2);
6376 {
6377 PyThreadState* __tstate = wxPyBeginAllowThreads();
6378 (arg1)->SetY(arg2);
6379 wxPyEndAllowThreads(__tstate);
6380 if (PyErr_Occurred()) SWIG_fail;
6381 }
6382 resultobj = SWIG_Py_Void();
6383 return resultobj;
6384 fail:
6385 return NULL;
6386 }
6387
6388
6389 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6390 PyObject *resultobj = 0;
6391 wxRect *arg1 = (wxRect *) 0 ;
6392 int result;
6393 void *argp1 = 0 ;
6394 int res1 = 0 ;
6395 PyObject *swig_obj[1] ;
6396
6397 if (!args) SWIG_fail;
6398 swig_obj[0] = args;
6399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6400 if (!SWIG_IsOK(res1)) {
6401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6402 }
6403 arg1 = reinterpret_cast< wxRect * >(argp1);
6404 {
6405 PyThreadState* __tstate = wxPyBeginAllowThreads();
6406 result = (int)((wxRect const *)arg1)->GetWidth();
6407 wxPyEndAllowThreads(__tstate);
6408 if (PyErr_Occurred()) SWIG_fail;
6409 }
6410 resultobj = SWIG_From_int(static_cast< int >(result));
6411 return resultobj;
6412 fail:
6413 return NULL;
6414 }
6415
6416
6417 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6418 PyObject *resultobj = 0;
6419 wxRect *arg1 = (wxRect *) 0 ;
6420 int arg2 ;
6421 void *argp1 = 0 ;
6422 int res1 = 0 ;
6423 int val2 ;
6424 int ecode2 = 0 ;
6425 PyObject * obj0 = 0 ;
6426 PyObject * obj1 = 0 ;
6427 char * kwnames[] = {
6428 (char *) "self",(char *) "w", NULL
6429 };
6430
6431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6433 if (!SWIG_IsOK(res1)) {
6434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6435 }
6436 arg1 = reinterpret_cast< wxRect * >(argp1);
6437 ecode2 = SWIG_AsVal_int(obj1, &val2);
6438 if (!SWIG_IsOK(ecode2)) {
6439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6440 }
6441 arg2 = static_cast< int >(val2);
6442 {
6443 PyThreadState* __tstate = wxPyBeginAllowThreads();
6444 (arg1)->SetWidth(arg2);
6445 wxPyEndAllowThreads(__tstate);
6446 if (PyErr_Occurred()) SWIG_fail;
6447 }
6448 resultobj = SWIG_Py_Void();
6449 return resultobj;
6450 fail:
6451 return NULL;
6452 }
6453
6454
6455 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6456 PyObject *resultobj = 0;
6457 wxRect *arg1 = (wxRect *) 0 ;
6458 int result;
6459 void *argp1 = 0 ;
6460 int res1 = 0 ;
6461 PyObject *swig_obj[1] ;
6462
6463 if (!args) SWIG_fail;
6464 swig_obj[0] = args;
6465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6466 if (!SWIG_IsOK(res1)) {
6467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6468 }
6469 arg1 = reinterpret_cast< wxRect * >(argp1);
6470 {
6471 PyThreadState* __tstate = wxPyBeginAllowThreads();
6472 result = (int)((wxRect const *)arg1)->GetHeight();
6473 wxPyEndAllowThreads(__tstate);
6474 if (PyErr_Occurred()) SWIG_fail;
6475 }
6476 resultobj = SWIG_From_int(static_cast< int >(result));
6477 return resultobj;
6478 fail:
6479 return NULL;
6480 }
6481
6482
6483 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6484 PyObject *resultobj = 0;
6485 wxRect *arg1 = (wxRect *) 0 ;
6486 int arg2 ;
6487 void *argp1 = 0 ;
6488 int res1 = 0 ;
6489 int val2 ;
6490 int ecode2 = 0 ;
6491 PyObject * obj0 = 0 ;
6492 PyObject * obj1 = 0 ;
6493 char * kwnames[] = {
6494 (char *) "self",(char *) "h", NULL
6495 };
6496
6497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6499 if (!SWIG_IsOK(res1)) {
6500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6501 }
6502 arg1 = reinterpret_cast< wxRect * >(argp1);
6503 ecode2 = SWIG_AsVal_int(obj1, &val2);
6504 if (!SWIG_IsOK(ecode2)) {
6505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6506 }
6507 arg2 = static_cast< int >(val2);
6508 {
6509 PyThreadState* __tstate = wxPyBeginAllowThreads();
6510 (arg1)->SetHeight(arg2);
6511 wxPyEndAllowThreads(__tstate);
6512 if (PyErr_Occurred()) SWIG_fail;
6513 }
6514 resultobj = SWIG_Py_Void();
6515 return resultobj;
6516 fail:
6517 return NULL;
6518 }
6519
6520
6521 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6522 PyObject *resultobj = 0;
6523 wxRect *arg1 = (wxRect *) 0 ;
6524 wxPoint result;
6525 void *argp1 = 0 ;
6526 int res1 = 0 ;
6527 PyObject *swig_obj[1] ;
6528
6529 if (!args) SWIG_fail;
6530 swig_obj[0] = args;
6531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6532 if (!SWIG_IsOK(res1)) {
6533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6534 }
6535 arg1 = reinterpret_cast< wxRect * >(argp1);
6536 {
6537 PyThreadState* __tstate = wxPyBeginAllowThreads();
6538 result = ((wxRect const *)arg1)->GetPosition();
6539 wxPyEndAllowThreads(__tstate);
6540 if (PyErr_Occurred()) SWIG_fail;
6541 }
6542 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6543 return resultobj;
6544 fail:
6545 return NULL;
6546 }
6547
6548
6549 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6550 PyObject *resultobj = 0;
6551 wxRect *arg1 = (wxRect *) 0 ;
6552 wxPoint *arg2 = 0 ;
6553 void *argp1 = 0 ;
6554 int res1 = 0 ;
6555 wxPoint temp2 ;
6556 PyObject * obj0 = 0 ;
6557 PyObject * obj1 = 0 ;
6558 char * kwnames[] = {
6559 (char *) "self",(char *) "p", NULL
6560 };
6561
6562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6564 if (!SWIG_IsOK(res1)) {
6565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6566 }
6567 arg1 = reinterpret_cast< wxRect * >(argp1);
6568 {
6569 arg2 = &temp2;
6570 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6571 }
6572 {
6573 PyThreadState* __tstate = wxPyBeginAllowThreads();
6574 (arg1)->SetPosition((wxPoint const &)*arg2);
6575 wxPyEndAllowThreads(__tstate);
6576 if (PyErr_Occurred()) SWIG_fail;
6577 }
6578 resultobj = SWIG_Py_Void();
6579 return resultobj;
6580 fail:
6581 return NULL;
6582 }
6583
6584
6585 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6586 PyObject *resultobj = 0;
6587 wxRect *arg1 = (wxRect *) 0 ;
6588 wxSize result;
6589 void *argp1 = 0 ;
6590 int res1 = 0 ;
6591 PyObject *swig_obj[1] ;
6592
6593 if (!args) SWIG_fail;
6594 swig_obj[0] = args;
6595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6596 if (!SWIG_IsOK(res1)) {
6597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6598 }
6599 arg1 = reinterpret_cast< wxRect * >(argp1);
6600 {
6601 PyThreadState* __tstate = wxPyBeginAllowThreads();
6602 result = ((wxRect const *)arg1)->GetSize();
6603 wxPyEndAllowThreads(__tstate);
6604 if (PyErr_Occurred()) SWIG_fail;
6605 }
6606 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6607 return resultobj;
6608 fail:
6609 return NULL;
6610 }
6611
6612
6613 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6614 PyObject *resultobj = 0;
6615 wxRect *arg1 = (wxRect *) 0 ;
6616 wxSize *arg2 = 0 ;
6617 void *argp1 = 0 ;
6618 int res1 = 0 ;
6619 wxSize temp2 ;
6620 PyObject * obj0 = 0 ;
6621 PyObject * obj1 = 0 ;
6622 char * kwnames[] = {
6623 (char *) "self",(char *) "s", NULL
6624 };
6625
6626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6628 if (!SWIG_IsOK(res1)) {
6629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6630 }
6631 arg1 = reinterpret_cast< wxRect * >(argp1);
6632 {
6633 arg2 = &temp2;
6634 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6635 }
6636 {
6637 PyThreadState* __tstate = wxPyBeginAllowThreads();
6638 (arg1)->SetSize((wxSize const &)*arg2);
6639 wxPyEndAllowThreads(__tstate);
6640 if (PyErr_Occurred()) SWIG_fail;
6641 }
6642 resultobj = SWIG_Py_Void();
6643 return resultobj;
6644 fail:
6645 return NULL;
6646 }
6647
6648
6649 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6650 PyObject *resultobj = 0;
6651 wxRect *arg1 = (wxRect *) 0 ;
6652 bool result;
6653 void *argp1 = 0 ;
6654 int res1 = 0 ;
6655 PyObject *swig_obj[1] ;
6656
6657 if (!args) SWIG_fail;
6658 swig_obj[0] = args;
6659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6660 if (!SWIG_IsOK(res1)) {
6661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6662 }
6663 arg1 = reinterpret_cast< wxRect * >(argp1);
6664 {
6665 PyThreadState* __tstate = wxPyBeginAllowThreads();
6666 result = (bool)((wxRect const *)arg1)->IsEmpty();
6667 wxPyEndAllowThreads(__tstate);
6668 if (PyErr_Occurred()) SWIG_fail;
6669 }
6670 {
6671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6672 }
6673 return resultobj;
6674 fail:
6675 return NULL;
6676 }
6677
6678
6679 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6680 PyObject *resultobj = 0;
6681 wxRect *arg1 = (wxRect *) 0 ;
6682 wxPoint result;
6683 void *argp1 = 0 ;
6684 int res1 = 0 ;
6685 PyObject *swig_obj[1] ;
6686
6687 if (!args) SWIG_fail;
6688 swig_obj[0] = args;
6689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6690 if (!SWIG_IsOK(res1)) {
6691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6692 }
6693 arg1 = reinterpret_cast< wxRect * >(argp1);
6694 {
6695 PyThreadState* __tstate = wxPyBeginAllowThreads();
6696 result = ((wxRect const *)arg1)->GetTopLeft();
6697 wxPyEndAllowThreads(__tstate);
6698 if (PyErr_Occurred()) SWIG_fail;
6699 }
6700 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6701 return resultobj;
6702 fail:
6703 return NULL;
6704 }
6705
6706
6707 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6708 PyObject *resultobj = 0;
6709 wxRect *arg1 = (wxRect *) 0 ;
6710 wxPoint *arg2 = 0 ;
6711 void *argp1 = 0 ;
6712 int res1 = 0 ;
6713 wxPoint temp2 ;
6714 PyObject * obj0 = 0 ;
6715 PyObject * obj1 = 0 ;
6716 char * kwnames[] = {
6717 (char *) "self",(char *) "p", NULL
6718 };
6719
6720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6722 if (!SWIG_IsOK(res1)) {
6723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6724 }
6725 arg1 = reinterpret_cast< wxRect * >(argp1);
6726 {
6727 arg2 = &temp2;
6728 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6729 }
6730 {
6731 PyThreadState* __tstate = wxPyBeginAllowThreads();
6732 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6733 wxPyEndAllowThreads(__tstate);
6734 if (PyErr_Occurred()) SWIG_fail;
6735 }
6736 resultobj = SWIG_Py_Void();
6737 return resultobj;
6738 fail:
6739 return NULL;
6740 }
6741
6742
6743 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6744 PyObject *resultobj = 0;
6745 wxRect *arg1 = (wxRect *) 0 ;
6746 wxPoint result;
6747 void *argp1 = 0 ;
6748 int res1 = 0 ;
6749 PyObject *swig_obj[1] ;
6750
6751 if (!args) SWIG_fail;
6752 swig_obj[0] = args;
6753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6754 if (!SWIG_IsOK(res1)) {
6755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6756 }
6757 arg1 = reinterpret_cast< wxRect * >(argp1);
6758 {
6759 PyThreadState* __tstate = wxPyBeginAllowThreads();
6760 result = ((wxRect const *)arg1)->GetBottomRight();
6761 wxPyEndAllowThreads(__tstate);
6762 if (PyErr_Occurred()) SWIG_fail;
6763 }
6764 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6765 return resultobj;
6766 fail:
6767 return NULL;
6768 }
6769
6770
6771 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6772 PyObject *resultobj = 0;
6773 wxRect *arg1 = (wxRect *) 0 ;
6774 wxPoint *arg2 = 0 ;
6775 void *argp1 = 0 ;
6776 int res1 = 0 ;
6777 wxPoint temp2 ;
6778 PyObject * obj0 = 0 ;
6779 PyObject * obj1 = 0 ;
6780 char * kwnames[] = {
6781 (char *) "self",(char *) "p", NULL
6782 };
6783
6784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6786 if (!SWIG_IsOK(res1)) {
6787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6788 }
6789 arg1 = reinterpret_cast< wxRect * >(argp1);
6790 {
6791 arg2 = &temp2;
6792 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6793 }
6794 {
6795 PyThreadState* __tstate = wxPyBeginAllowThreads();
6796 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6797 wxPyEndAllowThreads(__tstate);
6798 if (PyErr_Occurred()) SWIG_fail;
6799 }
6800 resultobj = SWIG_Py_Void();
6801 return resultobj;
6802 fail:
6803 return NULL;
6804 }
6805
6806
6807 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6808 PyObject *resultobj = 0;
6809 wxRect *arg1 = (wxRect *) 0 ;
6810 int result;
6811 void *argp1 = 0 ;
6812 int res1 = 0 ;
6813 PyObject *swig_obj[1] ;
6814
6815 if (!args) SWIG_fail;
6816 swig_obj[0] = args;
6817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6818 if (!SWIG_IsOK(res1)) {
6819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6820 }
6821 arg1 = reinterpret_cast< wxRect * >(argp1);
6822 {
6823 PyThreadState* __tstate = wxPyBeginAllowThreads();
6824 result = (int)((wxRect const *)arg1)->GetLeft();
6825 wxPyEndAllowThreads(__tstate);
6826 if (PyErr_Occurred()) SWIG_fail;
6827 }
6828 resultobj = SWIG_From_int(static_cast< int >(result));
6829 return resultobj;
6830 fail:
6831 return NULL;
6832 }
6833
6834
6835 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6836 PyObject *resultobj = 0;
6837 wxRect *arg1 = (wxRect *) 0 ;
6838 int result;
6839 void *argp1 = 0 ;
6840 int res1 = 0 ;
6841 PyObject *swig_obj[1] ;
6842
6843 if (!args) SWIG_fail;
6844 swig_obj[0] = args;
6845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6846 if (!SWIG_IsOK(res1)) {
6847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6848 }
6849 arg1 = reinterpret_cast< wxRect * >(argp1);
6850 {
6851 PyThreadState* __tstate = wxPyBeginAllowThreads();
6852 result = (int)((wxRect const *)arg1)->GetTop();
6853 wxPyEndAllowThreads(__tstate);
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 resultobj = SWIG_From_int(static_cast< int >(result));
6857 return resultobj;
6858 fail:
6859 return NULL;
6860 }
6861
6862
6863 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6864 PyObject *resultobj = 0;
6865 wxRect *arg1 = (wxRect *) 0 ;
6866 int result;
6867 void *argp1 = 0 ;
6868 int res1 = 0 ;
6869 PyObject *swig_obj[1] ;
6870
6871 if (!args) SWIG_fail;
6872 swig_obj[0] = args;
6873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6874 if (!SWIG_IsOK(res1)) {
6875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6876 }
6877 arg1 = reinterpret_cast< wxRect * >(argp1);
6878 {
6879 PyThreadState* __tstate = wxPyBeginAllowThreads();
6880 result = (int)((wxRect const *)arg1)->GetBottom();
6881 wxPyEndAllowThreads(__tstate);
6882 if (PyErr_Occurred()) SWIG_fail;
6883 }
6884 resultobj = SWIG_From_int(static_cast< int >(result));
6885 return resultobj;
6886 fail:
6887 return NULL;
6888 }
6889
6890
6891 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6892 PyObject *resultobj = 0;
6893 wxRect *arg1 = (wxRect *) 0 ;
6894 int result;
6895 void *argp1 = 0 ;
6896 int res1 = 0 ;
6897 PyObject *swig_obj[1] ;
6898
6899 if (!args) SWIG_fail;
6900 swig_obj[0] = args;
6901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6902 if (!SWIG_IsOK(res1)) {
6903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6904 }
6905 arg1 = reinterpret_cast< wxRect * >(argp1);
6906 {
6907 PyThreadState* __tstate = wxPyBeginAllowThreads();
6908 result = (int)((wxRect const *)arg1)->GetRight();
6909 wxPyEndAllowThreads(__tstate);
6910 if (PyErr_Occurred()) SWIG_fail;
6911 }
6912 resultobj = SWIG_From_int(static_cast< int >(result));
6913 return resultobj;
6914 fail:
6915 return NULL;
6916 }
6917
6918
6919 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6920 PyObject *resultobj = 0;
6921 wxRect *arg1 = (wxRect *) 0 ;
6922 int arg2 ;
6923 void *argp1 = 0 ;
6924 int res1 = 0 ;
6925 int val2 ;
6926 int ecode2 = 0 ;
6927 PyObject * obj0 = 0 ;
6928 PyObject * obj1 = 0 ;
6929 char * kwnames[] = {
6930 (char *) "self",(char *) "left", NULL
6931 };
6932
6933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6935 if (!SWIG_IsOK(res1)) {
6936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6937 }
6938 arg1 = reinterpret_cast< wxRect * >(argp1);
6939 ecode2 = SWIG_AsVal_int(obj1, &val2);
6940 if (!SWIG_IsOK(ecode2)) {
6941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6942 }
6943 arg2 = static_cast< int >(val2);
6944 {
6945 PyThreadState* __tstate = wxPyBeginAllowThreads();
6946 (arg1)->SetLeft(arg2);
6947 wxPyEndAllowThreads(__tstate);
6948 if (PyErr_Occurred()) SWIG_fail;
6949 }
6950 resultobj = SWIG_Py_Void();
6951 return resultobj;
6952 fail:
6953 return NULL;
6954 }
6955
6956
6957 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6958 PyObject *resultobj = 0;
6959 wxRect *arg1 = (wxRect *) 0 ;
6960 int arg2 ;
6961 void *argp1 = 0 ;
6962 int res1 = 0 ;
6963 int val2 ;
6964 int ecode2 = 0 ;
6965 PyObject * obj0 = 0 ;
6966 PyObject * obj1 = 0 ;
6967 char * kwnames[] = {
6968 (char *) "self",(char *) "right", NULL
6969 };
6970
6971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6973 if (!SWIG_IsOK(res1)) {
6974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6975 }
6976 arg1 = reinterpret_cast< wxRect * >(argp1);
6977 ecode2 = SWIG_AsVal_int(obj1, &val2);
6978 if (!SWIG_IsOK(ecode2)) {
6979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6980 }
6981 arg2 = static_cast< int >(val2);
6982 {
6983 PyThreadState* __tstate = wxPyBeginAllowThreads();
6984 (arg1)->SetRight(arg2);
6985 wxPyEndAllowThreads(__tstate);
6986 if (PyErr_Occurred()) SWIG_fail;
6987 }
6988 resultobj = SWIG_Py_Void();
6989 return resultobj;
6990 fail:
6991 return NULL;
6992 }
6993
6994
6995 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6996 PyObject *resultobj = 0;
6997 wxRect *arg1 = (wxRect *) 0 ;
6998 int arg2 ;
6999 void *argp1 = 0 ;
7000 int res1 = 0 ;
7001 int val2 ;
7002 int ecode2 = 0 ;
7003 PyObject * obj0 = 0 ;
7004 PyObject * obj1 = 0 ;
7005 char * kwnames[] = {
7006 (char *) "self",(char *) "top", NULL
7007 };
7008
7009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7011 if (!SWIG_IsOK(res1)) {
7012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7013 }
7014 arg1 = reinterpret_cast< wxRect * >(argp1);
7015 ecode2 = SWIG_AsVal_int(obj1, &val2);
7016 if (!SWIG_IsOK(ecode2)) {
7017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7018 }
7019 arg2 = static_cast< int >(val2);
7020 {
7021 PyThreadState* __tstate = wxPyBeginAllowThreads();
7022 (arg1)->SetTop(arg2);
7023 wxPyEndAllowThreads(__tstate);
7024 if (PyErr_Occurred()) SWIG_fail;
7025 }
7026 resultobj = SWIG_Py_Void();
7027 return resultobj;
7028 fail:
7029 return NULL;
7030 }
7031
7032
7033 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7034 PyObject *resultobj = 0;
7035 wxRect *arg1 = (wxRect *) 0 ;
7036 int arg2 ;
7037 void *argp1 = 0 ;
7038 int res1 = 0 ;
7039 int val2 ;
7040 int ecode2 = 0 ;
7041 PyObject * obj0 = 0 ;
7042 PyObject * obj1 = 0 ;
7043 char * kwnames[] = {
7044 (char *) "self",(char *) "bottom", NULL
7045 };
7046
7047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7049 if (!SWIG_IsOK(res1)) {
7050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7051 }
7052 arg1 = reinterpret_cast< wxRect * >(argp1);
7053 ecode2 = SWIG_AsVal_int(obj1, &val2);
7054 if (!SWIG_IsOK(ecode2)) {
7055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7056 }
7057 arg2 = static_cast< int >(val2);
7058 {
7059 PyThreadState* __tstate = wxPyBeginAllowThreads();
7060 (arg1)->SetBottom(arg2);
7061 wxPyEndAllowThreads(__tstate);
7062 if (PyErr_Occurred()) SWIG_fail;
7063 }
7064 resultobj = SWIG_Py_Void();
7065 return resultobj;
7066 fail:
7067 return NULL;
7068 }
7069
7070
7071 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7072 PyObject *resultobj = 0;
7073 wxRect *arg1 = (wxRect *) 0 ;
7074 int arg2 ;
7075 int arg3 ;
7076 wxRect *result = 0 ;
7077 void *argp1 = 0 ;
7078 int res1 = 0 ;
7079 int val2 ;
7080 int ecode2 = 0 ;
7081 int val3 ;
7082 int ecode3 = 0 ;
7083 PyObject * obj0 = 0 ;
7084 PyObject * obj1 = 0 ;
7085 PyObject * obj2 = 0 ;
7086 char * kwnames[] = {
7087 (char *) "self",(char *) "dx",(char *) "dy", NULL
7088 };
7089
7090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7092 if (!SWIG_IsOK(res1)) {
7093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7094 }
7095 arg1 = reinterpret_cast< wxRect * >(argp1);
7096 ecode2 = SWIG_AsVal_int(obj1, &val2);
7097 if (!SWIG_IsOK(ecode2)) {
7098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7099 }
7100 arg2 = static_cast< int >(val2);
7101 ecode3 = SWIG_AsVal_int(obj2, &val3);
7102 if (!SWIG_IsOK(ecode3)) {
7103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7104 }
7105 arg3 = static_cast< int >(val3);
7106 {
7107 PyThreadState* __tstate = wxPyBeginAllowThreads();
7108 {
7109 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7110 result = (wxRect *) &_result_ref;
7111 }
7112 wxPyEndAllowThreads(__tstate);
7113 if (PyErr_Occurred()) SWIG_fail;
7114 }
7115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7116 return resultobj;
7117 fail:
7118 return NULL;
7119 }
7120
7121
7122 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7123 PyObject *resultobj = 0;
7124 wxRect *arg1 = (wxRect *) 0 ;
7125 int arg2 ;
7126 int arg3 ;
7127 wxRect *result = 0 ;
7128 void *argp1 = 0 ;
7129 int res1 = 0 ;
7130 int val2 ;
7131 int ecode2 = 0 ;
7132 int val3 ;
7133 int ecode3 = 0 ;
7134 PyObject * obj0 = 0 ;
7135 PyObject * obj1 = 0 ;
7136 PyObject * obj2 = 0 ;
7137 char * kwnames[] = {
7138 (char *) "self",(char *) "dx",(char *) "dy", NULL
7139 };
7140
7141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7143 if (!SWIG_IsOK(res1)) {
7144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7145 }
7146 arg1 = reinterpret_cast< wxRect * >(argp1);
7147 ecode2 = SWIG_AsVal_int(obj1, &val2);
7148 if (!SWIG_IsOK(ecode2)) {
7149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7150 }
7151 arg2 = static_cast< int >(val2);
7152 ecode3 = SWIG_AsVal_int(obj2, &val3);
7153 if (!SWIG_IsOK(ecode3)) {
7154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7155 }
7156 arg3 = static_cast< int >(val3);
7157 {
7158 PyThreadState* __tstate = wxPyBeginAllowThreads();
7159 {
7160 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7161 result = (wxRect *) &_result_ref;
7162 }
7163 wxPyEndAllowThreads(__tstate);
7164 if (PyErr_Occurred()) SWIG_fail;
7165 }
7166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7167 return resultobj;
7168 fail:
7169 return NULL;
7170 }
7171
7172
7173 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7174 PyObject *resultobj = 0;
7175 wxRect *arg1 = (wxRect *) 0 ;
7176 int arg2 ;
7177 int arg3 ;
7178 void *argp1 = 0 ;
7179 int res1 = 0 ;
7180 int val2 ;
7181 int ecode2 = 0 ;
7182 int val3 ;
7183 int ecode3 = 0 ;
7184 PyObject * obj0 = 0 ;
7185 PyObject * obj1 = 0 ;
7186 PyObject * obj2 = 0 ;
7187 char * kwnames[] = {
7188 (char *) "self",(char *) "dx",(char *) "dy", NULL
7189 };
7190
7191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7193 if (!SWIG_IsOK(res1)) {
7194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7195 }
7196 arg1 = reinterpret_cast< wxRect * >(argp1);
7197 ecode2 = SWIG_AsVal_int(obj1, &val2);
7198 if (!SWIG_IsOK(ecode2)) {
7199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7200 }
7201 arg2 = static_cast< int >(val2);
7202 ecode3 = SWIG_AsVal_int(obj2, &val3);
7203 if (!SWIG_IsOK(ecode3)) {
7204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7205 }
7206 arg3 = static_cast< int >(val3);
7207 {
7208 PyThreadState* __tstate = wxPyBeginAllowThreads();
7209 (arg1)->Offset(arg2,arg3);
7210 wxPyEndAllowThreads(__tstate);
7211 if (PyErr_Occurred()) SWIG_fail;
7212 }
7213 resultobj = SWIG_Py_Void();
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7221 PyObject *resultobj = 0;
7222 wxRect *arg1 = (wxRect *) 0 ;
7223 wxPoint *arg2 = 0 ;
7224 void *argp1 = 0 ;
7225 int res1 = 0 ;
7226 wxPoint temp2 ;
7227 PyObject * obj0 = 0 ;
7228 PyObject * obj1 = 0 ;
7229 char * kwnames[] = {
7230 (char *) "self",(char *) "pt", NULL
7231 };
7232
7233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7235 if (!SWIG_IsOK(res1)) {
7236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7237 }
7238 arg1 = reinterpret_cast< wxRect * >(argp1);
7239 {
7240 arg2 = &temp2;
7241 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7242 }
7243 {
7244 PyThreadState* __tstate = wxPyBeginAllowThreads();
7245 (arg1)->Offset((wxPoint const &)*arg2);
7246 wxPyEndAllowThreads(__tstate);
7247 if (PyErr_Occurred()) SWIG_fail;
7248 }
7249 resultobj = SWIG_Py_Void();
7250 return resultobj;
7251 fail:
7252 return NULL;
7253 }
7254
7255
7256 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7257 PyObject *resultobj = 0;
7258 wxRect *arg1 = (wxRect *) 0 ;
7259 wxRect *arg2 = 0 ;
7260 wxRect result;
7261 void *argp1 = 0 ;
7262 int res1 = 0 ;
7263 wxRect temp2 ;
7264 PyObject * obj0 = 0 ;
7265 PyObject * obj1 = 0 ;
7266 char * kwnames[] = {
7267 (char *) "self",(char *) "rect", NULL
7268 };
7269
7270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7272 if (!SWIG_IsOK(res1)) {
7273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7274 }
7275 arg1 = reinterpret_cast< wxRect * >(argp1);
7276 {
7277 arg2 = &temp2;
7278 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7279 }
7280 {
7281 PyThreadState* __tstate = wxPyBeginAllowThreads();
7282 result = (arg1)->Intersect((wxRect const &)*arg2);
7283 wxPyEndAllowThreads(__tstate);
7284 if (PyErr_Occurred()) SWIG_fail;
7285 }
7286 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7287 return resultobj;
7288 fail:
7289 return NULL;
7290 }
7291
7292
7293 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7294 PyObject *resultobj = 0;
7295 wxRect *arg1 = (wxRect *) 0 ;
7296 wxRect *arg2 = 0 ;
7297 wxRect result;
7298 void *argp1 = 0 ;
7299 int res1 = 0 ;
7300 wxRect temp2 ;
7301 PyObject * obj0 = 0 ;
7302 PyObject * obj1 = 0 ;
7303 char * kwnames[] = {
7304 (char *) "self",(char *) "rect", NULL
7305 };
7306
7307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7309 if (!SWIG_IsOK(res1)) {
7310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7311 }
7312 arg1 = reinterpret_cast< wxRect * >(argp1);
7313 {
7314 arg2 = &temp2;
7315 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7316 }
7317 {
7318 PyThreadState* __tstate = wxPyBeginAllowThreads();
7319 result = (arg1)->Union((wxRect const &)*arg2);
7320 wxPyEndAllowThreads(__tstate);
7321 if (PyErr_Occurred()) SWIG_fail;
7322 }
7323 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7324 return resultobj;
7325 fail:
7326 return NULL;
7327 }
7328
7329
7330 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7331 PyObject *resultobj = 0;
7332 wxRect *arg1 = (wxRect *) 0 ;
7333 wxRect *arg2 = 0 ;
7334 wxRect result;
7335 void *argp1 = 0 ;
7336 int res1 = 0 ;
7337 wxRect temp2 ;
7338 PyObject * obj0 = 0 ;
7339 PyObject * obj1 = 0 ;
7340 char * kwnames[] = {
7341 (char *) "self",(char *) "rect", NULL
7342 };
7343
7344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7346 if (!SWIG_IsOK(res1)) {
7347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7348 }
7349 arg1 = reinterpret_cast< wxRect * >(argp1);
7350 {
7351 arg2 = &temp2;
7352 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7353 }
7354 {
7355 PyThreadState* __tstate = wxPyBeginAllowThreads();
7356 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7357 wxPyEndAllowThreads(__tstate);
7358 if (PyErr_Occurred()) SWIG_fail;
7359 }
7360 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7361 return resultobj;
7362 fail:
7363 return NULL;
7364 }
7365
7366
7367 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7368 PyObject *resultobj = 0;
7369 wxRect *arg1 = (wxRect *) 0 ;
7370 wxRect *arg2 = 0 ;
7371 wxRect *result = 0 ;
7372 void *argp1 = 0 ;
7373 int res1 = 0 ;
7374 wxRect temp2 ;
7375 PyObject * obj0 = 0 ;
7376 PyObject * obj1 = 0 ;
7377 char * kwnames[] = {
7378 (char *) "self",(char *) "rect", NULL
7379 };
7380
7381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7383 if (!SWIG_IsOK(res1)) {
7384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7385 }
7386 arg1 = reinterpret_cast< wxRect * >(argp1);
7387 {
7388 arg2 = &temp2;
7389 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7390 }
7391 {
7392 PyThreadState* __tstate = wxPyBeginAllowThreads();
7393 {
7394 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7395 result = (wxRect *) &_result_ref;
7396 }
7397 wxPyEndAllowThreads(__tstate);
7398 if (PyErr_Occurred()) SWIG_fail;
7399 }
7400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7401 return resultobj;
7402 fail:
7403 return NULL;
7404 }
7405
7406
7407 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7408 PyObject *resultobj = 0;
7409 wxRect *arg1 = (wxRect *) 0 ;
7410 PyObject *arg2 = (PyObject *) 0 ;
7411 bool result;
7412 void *argp1 = 0 ;
7413 int res1 = 0 ;
7414 PyObject * obj0 = 0 ;
7415 PyObject * obj1 = 0 ;
7416 char * kwnames[] = {
7417 (char *) "self",(char *) "other", NULL
7418 };
7419
7420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7422 if (!SWIG_IsOK(res1)) {
7423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7424 }
7425 arg1 = reinterpret_cast< wxRect * >(argp1);
7426 arg2 = obj1;
7427 {
7428 result = (bool)wxRect___eq__(arg1,arg2);
7429 if (PyErr_Occurred()) SWIG_fail;
7430 }
7431 {
7432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7433 }
7434 return resultobj;
7435 fail:
7436 return NULL;
7437 }
7438
7439
7440 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7441 PyObject *resultobj = 0;
7442 wxRect *arg1 = (wxRect *) 0 ;
7443 PyObject *arg2 = (PyObject *) 0 ;
7444 bool result;
7445 void *argp1 = 0 ;
7446 int res1 = 0 ;
7447 PyObject * obj0 = 0 ;
7448 PyObject * obj1 = 0 ;
7449 char * kwnames[] = {
7450 (char *) "self",(char *) "other", NULL
7451 };
7452
7453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7455 if (!SWIG_IsOK(res1)) {
7456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7457 }
7458 arg1 = reinterpret_cast< wxRect * >(argp1);
7459 arg2 = obj1;
7460 {
7461 result = (bool)wxRect___ne__(arg1,arg2);
7462 if (PyErr_Occurred()) SWIG_fail;
7463 }
7464 {
7465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7466 }
7467 return resultobj;
7468 fail:
7469 return NULL;
7470 }
7471
7472
7473 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7474 PyObject *resultobj = 0;
7475 wxRect *arg1 = (wxRect *) 0 ;
7476 int arg2 ;
7477 int arg3 ;
7478 bool result;
7479 void *argp1 = 0 ;
7480 int res1 = 0 ;
7481 int val2 ;
7482 int ecode2 = 0 ;
7483 int val3 ;
7484 int ecode3 = 0 ;
7485 PyObject * obj0 = 0 ;
7486 PyObject * obj1 = 0 ;
7487 PyObject * obj2 = 0 ;
7488 char * kwnames[] = {
7489 (char *) "self",(char *) "x",(char *) "y", NULL
7490 };
7491
7492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7494 if (!SWIG_IsOK(res1)) {
7495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7496 }
7497 arg1 = reinterpret_cast< wxRect * >(argp1);
7498 ecode2 = SWIG_AsVal_int(obj1, &val2);
7499 if (!SWIG_IsOK(ecode2)) {
7500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7501 }
7502 arg2 = static_cast< int >(val2);
7503 ecode3 = SWIG_AsVal_int(obj2, &val3);
7504 if (!SWIG_IsOK(ecode3)) {
7505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7506 }
7507 arg3 = static_cast< int >(val3);
7508 {
7509 PyThreadState* __tstate = wxPyBeginAllowThreads();
7510 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7511 wxPyEndAllowThreads(__tstate);
7512 if (PyErr_Occurred()) SWIG_fail;
7513 }
7514 {
7515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7516 }
7517 return resultobj;
7518 fail:
7519 return NULL;
7520 }
7521
7522
7523 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7524 PyObject *resultobj = 0;
7525 wxRect *arg1 = (wxRect *) 0 ;
7526 wxPoint *arg2 = 0 ;
7527 bool result;
7528 void *argp1 = 0 ;
7529 int res1 = 0 ;
7530 wxPoint temp2 ;
7531 PyObject * obj0 = 0 ;
7532 PyObject * obj1 = 0 ;
7533 char * kwnames[] = {
7534 (char *) "self",(char *) "pt", NULL
7535 };
7536
7537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7539 if (!SWIG_IsOK(res1)) {
7540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7541 }
7542 arg1 = reinterpret_cast< wxRect * >(argp1);
7543 {
7544 arg2 = &temp2;
7545 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7546 }
7547 {
7548 PyThreadState* __tstate = wxPyBeginAllowThreads();
7549 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7550 wxPyEndAllowThreads(__tstate);
7551 if (PyErr_Occurred()) SWIG_fail;
7552 }
7553 {
7554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7555 }
7556 return resultobj;
7557 fail:
7558 return NULL;
7559 }
7560
7561
7562 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7563 PyObject *resultobj = 0;
7564 wxRect *arg1 = (wxRect *) 0 ;
7565 wxRect *arg2 = 0 ;
7566 bool result;
7567 void *argp1 = 0 ;
7568 int res1 = 0 ;
7569 wxRect temp2 ;
7570 PyObject * obj0 = 0 ;
7571 PyObject * obj1 = 0 ;
7572 char * kwnames[] = {
7573 (char *) "self",(char *) "rect", NULL
7574 };
7575
7576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7578 if (!SWIG_IsOK(res1)) {
7579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7580 }
7581 arg1 = reinterpret_cast< wxRect * >(argp1);
7582 {
7583 arg2 = &temp2;
7584 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7585 }
7586 {
7587 PyThreadState* __tstate = wxPyBeginAllowThreads();
7588 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7589 wxPyEndAllowThreads(__tstate);
7590 if (PyErr_Occurred()) SWIG_fail;
7591 }
7592 {
7593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7594 }
7595 return resultobj;
7596 fail:
7597 return NULL;
7598 }
7599
7600
7601 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7602 PyObject *resultobj = 0;
7603 wxRect *arg1 = (wxRect *) 0 ;
7604 wxRect *arg2 = 0 ;
7605 int arg3 = (int) wxBOTH ;
7606 wxRect result;
7607 void *argp1 = 0 ;
7608 int res1 = 0 ;
7609 wxRect temp2 ;
7610 int val3 ;
7611 int ecode3 = 0 ;
7612 PyObject * obj0 = 0 ;
7613 PyObject * obj1 = 0 ;
7614 PyObject * obj2 = 0 ;
7615 char * kwnames[] = {
7616 (char *) "self",(char *) "r",(char *) "dir", NULL
7617 };
7618
7619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7621 if (!SWIG_IsOK(res1)) {
7622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7623 }
7624 arg1 = reinterpret_cast< wxRect * >(argp1);
7625 {
7626 arg2 = &temp2;
7627 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7628 }
7629 if (obj2) {
7630 ecode3 = SWIG_AsVal_int(obj2, &val3);
7631 if (!SWIG_IsOK(ecode3)) {
7632 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7633 }
7634 arg3 = static_cast< int >(val3);
7635 }
7636 {
7637 PyThreadState* __tstate = wxPyBeginAllowThreads();
7638 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7639 wxPyEndAllowThreads(__tstate);
7640 if (PyErr_Occurred()) SWIG_fail;
7641 }
7642 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7643 return resultobj;
7644 fail:
7645 return NULL;
7646 }
7647
7648
7649 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7650 PyObject *resultobj = 0;
7651 wxRect *arg1 = (wxRect *) 0 ;
7652 int arg2 ;
7653 void *argp1 = 0 ;
7654 int res1 = 0 ;
7655 int val2 ;
7656 int ecode2 = 0 ;
7657 PyObject *swig_obj[2] ;
7658
7659 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7661 if (!SWIG_IsOK(res1)) {
7662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7663 }
7664 arg1 = reinterpret_cast< wxRect * >(argp1);
7665 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7666 if (!SWIG_IsOK(ecode2)) {
7667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7668 }
7669 arg2 = static_cast< int >(val2);
7670 if (arg1) (arg1)->x = arg2;
7671
7672 resultobj = SWIG_Py_Void();
7673 return resultobj;
7674 fail:
7675 return NULL;
7676 }
7677
7678
7679 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7680 PyObject *resultobj = 0;
7681 wxRect *arg1 = (wxRect *) 0 ;
7682 int result;
7683 void *argp1 = 0 ;
7684 int res1 = 0 ;
7685 PyObject *swig_obj[1] ;
7686
7687 if (!args) SWIG_fail;
7688 swig_obj[0] = args;
7689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7690 if (!SWIG_IsOK(res1)) {
7691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7692 }
7693 arg1 = reinterpret_cast< wxRect * >(argp1);
7694 result = (int) ((arg1)->x);
7695 resultobj = SWIG_From_int(static_cast< int >(result));
7696 return resultobj;
7697 fail:
7698 return NULL;
7699 }
7700
7701
7702 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7703 PyObject *resultobj = 0;
7704 wxRect *arg1 = (wxRect *) 0 ;
7705 int arg2 ;
7706 void *argp1 = 0 ;
7707 int res1 = 0 ;
7708 int val2 ;
7709 int ecode2 = 0 ;
7710 PyObject *swig_obj[2] ;
7711
7712 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7714 if (!SWIG_IsOK(res1)) {
7715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7716 }
7717 arg1 = reinterpret_cast< wxRect * >(argp1);
7718 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7719 if (!SWIG_IsOK(ecode2)) {
7720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7721 }
7722 arg2 = static_cast< int >(val2);
7723 if (arg1) (arg1)->y = arg2;
7724
7725 resultobj = SWIG_Py_Void();
7726 return resultobj;
7727 fail:
7728 return NULL;
7729 }
7730
7731
7732 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7733 PyObject *resultobj = 0;
7734 wxRect *arg1 = (wxRect *) 0 ;
7735 int result;
7736 void *argp1 = 0 ;
7737 int res1 = 0 ;
7738 PyObject *swig_obj[1] ;
7739
7740 if (!args) SWIG_fail;
7741 swig_obj[0] = args;
7742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7743 if (!SWIG_IsOK(res1)) {
7744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7745 }
7746 arg1 = reinterpret_cast< wxRect * >(argp1);
7747 result = (int) ((arg1)->y);
7748 resultobj = SWIG_From_int(static_cast< int >(result));
7749 return resultobj;
7750 fail:
7751 return NULL;
7752 }
7753
7754
7755 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7756 PyObject *resultobj = 0;
7757 wxRect *arg1 = (wxRect *) 0 ;
7758 int arg2 ;
7759 void *argp1 = 0 ;
7760 int res1 = 0 ;
7761 int val2 ;
7762 int ecode2 = 0 ;
7763 PyObject *swig_obj[2] ;
7764
7765 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7767 if (!SWIG_IsOK(res1)) {
7768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7769 }
7770 arg1 = reinterpret_cast< wxRect * >(argp1);
7771 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7772 if (!SWIG_IsOK(ecode2)) {
7773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7774 }
7775 arg2 = static_cast< int >(val2);
7776 if (arg1) (arg1)->width = arg2;
7777
7778 resultobj = SWIG_Py_Void();
7779 return resultobj;
7780 fail:
7781 return NULL;
7782 }
7783
7784
7785 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7786 PyObject *resultobj = 0;
7787 wxRect *arg1 = (wxRect *) 0 ;
7788 int result;
7789 void *argp1 = 0 ;
7790 int res1 = 0 ;
7791 PyObject *swig_obj[1] ;
7792
7793 if (!args) SWIG_fail;
7794 swig_obj[0] = args;
7795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7796 if (!SWIG_IsOK(res1)) {
7797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7798 }
7799 arg1 = reinterpret_cast< wxRect * >(argp1);
7800 result = (int) ((arg1)->width);
7801 resultobj = SWIG_From_int(static_cast< int >(result));
7802 return resultobj;
7803 fail:
7804 return NULL;
7805 }
7806
7807
7808 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7809 PyObject *resultobj = 0;
7810 wxRect *arg1 = (wxRect *) 0 ;
7811 int arg2 ;
7812 void *argp1 = 0 ;
7813 int res1 = 0 ;
7814 int val2 ;
7815 int ecode2 = 0 ;
7816 PyObject *swig_obj[2] ;
7817
7818 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7820 if (!SWIG_IsOK(res1)) {
7821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7822 }
7823 arg1 = reinterpret_cast< wxRect * >(argp1);
7824 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7825 if (!SWIG_IsOK(ecode2)) {
7826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7827 }
7828 arg2 = static_cast< int >(val2);
7829 if (arg1) (arg1)->height = arg2;
7830
7831 resultobj = SWIG_Py_Void();
7832 return resultobj;
7833 fail:
7834 return NULL;
7835 }
7836
7837
7838 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7839 PyObject *resultobj = 0;
7840 wxRect *arg1 = (wxRect *) 0 ;
7841 int result;
7842 void *argp1 = 0 ;
7843 int res1 = 0 ;
7844 PyObject *swig_obj[1] ;
7845
7846 if (!args) SWIG_fail;
7847 swig_obj[0] = args;
7848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7849 if (!SWIG_IsOK(res1)) {
7850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7851 }
7852 arg1 = reinterpret_cast< wxRect * >(argp1);
7853 result = (int) ((arg1)->height);
7854 resultobj = SWIG_From_int(static_cast< int >(result));
7855 return resultobj;
7856 fail:
7857 return NULL;
7858 }
7859
7860
7861 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7862 PyObject *resultobj = 0;
7863 wxRect *arg1 = (wxRect *) 0 ;
7864 int arg2 = (int) 0 ;
7865 int arg3 = (int) 0 ;
7866 int arg4 = (int) 0 ;
7867 int arg5 = (int) 0 ;
7868 void *argp1 = 0 ;
7869 int res1 = 0 ;
7870 int val2 ;
7871 int ecode2 = 0 ;
7872 int val3 ;
7873 int ecode3 = 0 ;
7874 int val4 ;
7875 int ecode4 = 0 ;
7876 int val5 ;
7877 int ecode5 = 0 ;
7878 PyObject * obj0 = 0 ;
7879 PyObject * obj1 = 0 ;
7880 PyObject * obj2 = 0 ;
7881 PyObject * obj3 = 0 ;
7882 PyObject * obj4 = 0 ;
7883 char * kwnames[] = {
7884 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7885 };
7886
7887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7889 if (!SWIG_IsOK(res1)) {
7890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7891 }
7892 arg1 = reinterpret_cast< wxRect * >(argp1);
7893 if (obj1) {
7894 ecode2 = SWIG_AsVal_int(obj1, &val2);
7895 if (!SWIG_IsOK(ecode2)) {
7896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7897 }
7898 arg2 = static_cast< int >(val2);
7899 }
7900 if (obj2) {
7901 ecode3 = SWIG_AsVal_int(obj2, &val3);
7902 if (!SWIG_IsOK(ecode3)) {
7903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7904 }
7905 arg3 = static_cast< int >(val3);
7906 }
7907 if (obj3) {
7908 ecode4 = SWIG_AsVal_int(obj3, &val4);
7909 if (!SWIG_IsOK(ecode4)) {
7910 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7911 }
7912 arg4 = static_cast< int >(val4);
7913 }
7914 if (obj4) {
7915 ecode5 = SWIG_AsVal_int(obj4, &val5);
7916 if (!SWIG_IsOK(ecode5)) {
7917 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7918 }
7919 arg5 = static_cast< int >(val5);
7920 }
7921 {
7922 PyThreadState* __tstate = wxPyBeginAllowThreads();
7923 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7924 wxPyEndAllowThreads(__tstate);
7925 if (PyErr_Occurred()) SWIG_fail;
7926 }
7927 resultobj = SWIG_Py_Void();
7928 return resultobj;
7929 fail:
7930 return NULL;
7931 }
7932
7933
7934 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7935 PyObject *resultobj = 0;
7936 wxRect *arg1 = (wxRect *) 0 ;
7937 PyObject *result = 0 ;
7938 void *argp1 = 0 ;
7939 int res1 = 0 ;
7940 PyObject *swig_obj[1] ;
7941
7942 if (!args) SWIG_fail;
7943 swig_obj[0] = args;
7944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7945 if (!SWIG_IsOK(res1)) {
7946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7947 }
7948 arg1 = reinterpret_cast< wxRect * >(argp1);
7949 {
7950 PyThreadState* __tstate = wxPyBeginAllowThreads();
7951 result = (PyObject *)wxRect_Get(arg1);
7952 wxPyEndAllowThreads(__tstate);
7953 if (PyErr_Occurred()) SWIG_fail;
7954 }
7955 resultobj = result;
7956 return resultobj;
7957 fail:
7958 return NULL;
7959 }
7960
7961
7962 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7963 PyObject *obj;
7964 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7965 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7966 return SWIG_Py_Void();
7967 }
7968
7969 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7970 return SWIG_Python_InitShadowInstance(args);
7971 }
7972
7973 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7974 PyObject *resultobj = 0;
7975 wxRect *arg1 = (wxRect *) 0 ;
7976 wxRect *arg2 = (wxRect *) 0 ;
7977 PyObject *result = 0 ;
7978 void *argp1 = 0 ;
7979 int res1 = 0 ;
7980 void *argp2 = 0 ;
7981 int res2 = 0 ;
7982 PyObject * obj0 = 0 ;
7983 PyObject * obj1 = 0 ;
7984 char * kwnames[] = {
7985 (char *) "r1",(char *) "r2", NULL
7986 };
7987
7988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7990 if (!SWIG_IsOK(res1)) {
7991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7992 }
7993 arg1 = reinterpret_cast< wxRect * >(argp1);
7994 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7995 if (!SWIG_IsOK(res2)) {
7996 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7997 }
7998 arg2 = reinterpret_cast< wxRect * >(argp2);
7999 {
8000 if (!wxPyCheckForApp()) SWIG_fail;
8001 PyThreadState* __tstate = wxPyBeginAllowThreads();
8002 result = (PyObject *)wxIntersectRect(arg1,arg2);
8003 wxPyEndAllowThreads(__tstate);
8004 if (PyErr_Occurred()) SWIG_fail;
8005 }
8006 resultobj = result;
8007 return resultobj;
8008 fail:
8009 return NULL;
8010 }
8011
8012
8013 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8014 PyObject *resultobj = 0;
8015 double arg1 = (double) 0.0 ;
8016 double arg2 = (double) 0.0 ;
8017 wxPoint2D *result = 0 ;
8018 double val1 ;
8019 int ecode1 = 0 ;
8020 double val2 ;
8021 int ecode2 = 0 ;
8022 PyObject * obj0 = 0 ;
8023 PyObject * obj1 = 0 ;
8024 char * kwnames[] = {
8025 (char *) "x",(char *) "y", NULL
8026 };
8027
8028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8029 if (obj0) {
8030 ecode1 = SWIG_AsVal_double(obj0, &val1);
8031 if (!SWIG_IsOK(ecode1)) {
8032 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8033 }
8034 arg1 = static_cast< double >(val1);
8035 }
8036 if (obj1) {
8037 ecode2 = SWIG_AsVal_double(obj1, &val2);
8038 if (!SWIG_IsOK(ecode2)) {
8039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8040 }
8041 arg2 = static_cast< double >(val2);
8042 }
8043 {
8044 PyThreadState* __tstate = wxPyBeginAllowThreads();
8045 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8046 wxPyEndAllowThreads(__tstate);
8047 if (PyErr_Occurred()) SWIG_fail;
8048 }
8049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8050 return resultobj;
8051 fail:
8052 return NULL;
8053 }
8054
8055
8056 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8057 PyObject *resultobj = 0;
8058 wxPoint2D *arg1 = 0 ;
8059 wxPoint2D *result = 0 ;
8060 wxPoint2D temp1 ;
8061 PyObject * obj0 = 0 ;
8062 char * kwnames[] = {
8063 (char *) "pt", NULL
8064 };
8065
8066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8067 {
8068 arg1 = &temp1;
8069 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8070 }
8071 {
8072 PyThreadState* __tstate = wxPyBeginAllowThreads();
8073 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8074 wxPyEndAllowThreads(__tstate);
8075 if (PyErr_Occurred()) SWIG_fail;
8076 }
8077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8078 return resultobj;
8079 fail:
8080 return NULL;
8081 }
8082
8083
8084 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8085 PyObject *resultobj = 0;
8086 wxPoint *arg1 = 0 ;
8087 wxPoint2D *result = 0 ;
8088 wxPoint temp1 ;
8089 PyObject * obj0 = 0 ;
8090 char * kwnames[] = {
8091 (char *) "pt", NULL
8092 };
8093
8094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8095 {
8096 arg1 = &temp1;
8097 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8098 }
8099 {
8100 PyThreadState* __tstate = wxPyBeginAllowThreads();
8101 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8102 wxPyEndAllowThreads(__tstate);
8103 if (PyErr_Occurred()) SWIG_fail;
8104 }
8105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8106 return resultobj;
8107 fail:
8108 return NULL;
8109 }
8110
8111
8112 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8113 PyObject *resultobj = 0;
8114 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8115 int *arg2 = (int *) 0 ;
8116 int *arg3 = (int *) 0 ;
8117 void *argp1 = 0 ;
8118 int res1 = 0 ;
8119 int temp2 ;
8120 int res2 = SWIG_TMPOBJ ;
8121 int temp3 ;
8122 int res3 = SWIG_TMPOBJ ;
8123 PyObject *swig_obj[1] ;
8124
8125 arg2 = &temp2;
8126 arg3 = &temp3;
8127 if (!args) SWIG_fail;
8128 swig_obj[0] = args;
8129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8130 if (!SWIG_IsOK(res1)) {
8131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8132 }
8133 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8134 {
8135 PyThreadState* __tstate = wxPyBeginAllowThreads();
8136 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 resultobj = SWIG_Py_Void();
8141 if (SWIG_IsTmpObj(res2)) {
8142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8143 } else {
8144 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8146 }
8147 if (SWIG_IsTmpObj(res3)) {
8148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8149 } else {
8150 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8152 }
8153 return resultobj;
8154 fail:
8155 return NULL;
8156 }
8157
8158
8159 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8160 PyObject *resultobj = 0;
8161 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8162 int *arg2 = (int *) 0 ;
8163 int *arg3 = (int *) 0 ;
8164 void *argp1 = 0 ;
8165 int res1 = 0 ;
8166 int temp2 ;
8167 int res2 = SWIG_TMPOBJ ;
8168 int temp3 ;
8169 int res3 = SWIG_TMPOBJ ;
8170 PyObject *swig_obj[1] ;
8171
8172 arg2 = &temp2;
8173 arg3 = &temp3;
8174 if (!args) SWIG_fail;
8175 swig_obj[0] = args;
8176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8177 if (!SWIG_IsOK(res1)) {
8178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8179 }
8180 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8181 {
8182 PyThreadState* __tstate = wxPyBeginAllowThreads();
8183 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8184 wxPyEndAllowThreads(__tstate);
8185 if (PyErr_Occurred()) SWIG_fail;
8186 }
8187 resultobj = SWIG_Py_Void();
8188 if (SWIG_IsTmpObj(res2)) {
8189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8190 } else {
8191 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8193 }
8194 if (SWIG_IsTmpObj(res3)) {
8195 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8196 } else {
8197 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8198 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8199 }
8200 return resultobj;
8201 fail:
8202 return NULL;
8203 }
8204
8205
8206 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8207 PyObject *resultobj = 0;
8208 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8209 double result;
8210 void *argp1 = 0 ;
8211 int res1 = 0 ;
8212 PyObject *swig_obj[1] ;
8213
8214 if (!args) SWIG_fail;
8215 swig_obj[0] = args;
8216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8217 if (!SWIG_IsOK(res1)) {
8218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8219 }
8220 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8221 {
8222 PyThreadState* __tstate = wxPyBeginAllowThreads();
8223 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8224 wxPyEndAllowThreads(__tstate);
8225 if (PyErr_Occurred()) SWIG_fail;
8226 }
8227 resultobj = SWIG_From_double(static_cast< double >(result));
8228 return resultobj;
8229 fail:
8230 return NULL;
8231 }
8232
8233
8234 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8235 PyObject *resultobj = 0;
8236 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8237 double result;
8238 void *argp1 = 0 ;
8239 int res1 = 0 ;
8240 PyObject *swig_obj[1] ;
8241
8242 if (!args) SWIG_fail;
8243 swig_obj[0] = args;
8244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8245 if (!SWIG_IsOK(res1)) {
8246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8247 }
8248 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8249 {
8250 PyThreadState* __tstate = wxPyBeginAllowThreads();
8251 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8252 wxPyEndAllowThreads(__tstate);
8253 if (PyErr_Occurred()) SWIG_fail;
8254 }
8255 resultobj = SWIG_From_double(static_cast< double >(result));
8256 return resultobj;
8257 fail:
8258 return NULL;
8259 }
8260
8261
8262 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8263 PyObject *resultobj = 0;
8264 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8265 double arg2 ;
8266 void *argp1 = 0 ;
8267 int res1 = 0 ;
8268 double val2 ;
8269 int ecode2 = 0 ;
8270 PyObject * obj0 = 0 ;
8271 PyObject * obj1 = 0 ;
8272 char * kwnames[] = {
8273 (char *) "self",(char *) "length", NULL
8274 };
8275
8276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8278 if (!SWIG_IsOK(res1)) {
8279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8280 }
8281 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8282 ecode2 = SWIG_AsVal_double(obj1, &val2);
8283 if (!SWIG_IsOK(ecode2)) {
8284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8285 }
8286 arg2 = static_cast< double >(val2);
8287 {
8288 PyThreadState* __tstate = wxPyBeginAllowThreads();
8289 (arg1)->SetVectorLength(arg2);
8290 wxPyEndAllowThreads(__tstate);
8291 if (PyErr_Occurred()) SWIG_fail;
8292 }
8293 resultobj = SWIG_Py_Void();
8294 return resultobj;
8295 fail:
8296 return NULL;
8297 }
8298
8299
8300 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8301 PyObject *resultobj = 0;
8302 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8303 double arg2 ;
8304 void *argp1 = 0 ;
8305 int res1 = 0 ;
8306 double val2 ;
8307 int ecode2 = 0 ;
8308 PyObject * obj0 = 0 ;
8309 PyObject * obj1 = 0 ;
8310 char * kwnames[] = {
8311 (char *) "self",(char *) "degrees", NULL
8312 };
8313
8314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8316 if (!SWIG_IsOK(res1)) {
8317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8318 }
8319 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8320 ecode2 = SWIG_AsVal_double(obj1, &val2);
8321 if (!SWIG_IsOK(ecode2)) {
8322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8323 }
8324 arg2 = static_cast< double >(val2);
8325 {
8326 PyThreadState* __tstate = wxPyBeginAllowThreads();
8327 (arg1)->SetVectorAngle(arg2);
8328 wxPyEndAllowThreads(__tstate);
8329 if (PyErr_Occurred()) SWIG_fail;
8330 }
8331 resultobj = SWIG_Py_Void();
8332 return resultobj;
8333 fail:
8334 return NULL;
8335 }
8336
8337
8338 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8339 PyObject *resultobj = 0;
8340 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8341 wxPoint2D *arg2 = 0 ;
8342 double result;
8343 void *argp1 = 0 ;
8344 int res1 = 0 ;
8345 wxPoint2D temp2 ;
8346 PyObject * obj0 = 0 ;
8347 PyObject * obj1 = 0 ;
8348 char * kwnames[] = {
8349 (char *) "self",(char *) "pt", NULL
8350 };
8351
8352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8354 if (!SWIG_IsOK(res1)) {
8355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8356 }
8357 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8358 {
8359 arg2 = &temp2;
8360 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8361 }
8362 {
8363 PyThreadState* __tstate = wxPyBeginAllowThreads();
8364 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8365 wxPyEndAllowThreads(__tstate);
8366 if (PyErr_Occurred()) SWIG_fail;
8367 }
8368 resultobj = SWIG_From_double(static_cast< double >(result));
8369 return resultobj;
8370 fail:
8371 return NULL;
8372 }
8373
8374
8375 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8376 PyObject *resultobj = 0;
8377 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8378 wxPoint2D *arg2 = 0 ;
8379 double result;
8380 void *argp1 = 0 ;
8381 int res1 = 0 ;
8382 wxPoint2D temp2 ;
8383 PyObject * obj0 = 0 ;
8384 PyObject * obj1 = 0 ;
8385 char * kwnames[] = {
8386 (char *) "self",(char *) "pt", NULL
8387 };
8388
8389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8391 if (!SWIG_IsOK(res1)) {
8392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8393 }
8394 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8395 {
8396 arg2 = &temp2;
8397 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8398 }
8399 {
8400 PyThreadState* __tstate = wxPyBeginAllowThreads();
8401 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8402 wxPyEndAllowThreads(__tstate);
8403 if (PyErr_Occurred()) SWIG_fail;
8404 }
8405 resultobj = SWIG_From_double(static_cast< double >(result));
8406 return resultobj;
8407 fail:
8408 return NULL;
8409 }
8410
8411
8412 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8413 PyObject *resultobj = 0;
8414 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8415 wxPoint2D *arg2 = 0 ;
8416 double result;
8417 void *argp1 = 0 ;
8418 int res1 = 0 ;
8419 wxPoint2D temp2 ;
8420 PyObject * obj0 = 0 ;
8421 PyObject * obj1 = 0 ;
8422 char * kwnames[] = {
8423 (char *) "self",(char *) "vec", NULL
8424 };
8425
8426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8428 if (!SWIG_IsOK(res1)) {
8429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8430 }
8431 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8432 {
8433 arg2 = &temp2;
8434 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8435 }
8436 {
8437 PyThreadState* __tstate = wxPyBeginAllowThreads();
8438 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8439 wxPyEndAllowThreads(__tstate);
8440 if (PyErr_Occurred()) SWIG_fail;
8441 }
8442 resultobj = SWIG_From_double(static_cast< double >(result));
8443 return resultobj;
8444 fail:
8445 return NULL;
8446 }
8447
8448
8449 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8450 PyObject *resultobj = 0;
8451 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8452 wxPoint2D *arg2 = 0 ;
8453 double result;
8454 void *argp1 = 0 ;
8455 int res1 = 0 ;
8456 wxPoint2D temp2 ;
8457 PyObject * obj0 = 0 ;
8458 PyObject * obj1 = 0 ;
8459 char * kwnames[] = {
8460 (char *) "self",(char *) "vec", NULL
8461 };
8462
8463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8465 if (!SWIG_IsOK(res1)) {
8466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8467 }
8468 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8469 {
8470 arg2 = &temp2;
8471 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8472 }
8473 {
8474 PyThreadState* __tstate = wxPyBeginAllowThreads();
8475 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8476 wxPyEndAllowThreads(__tstate);
8477 if (PyErr_Occurred()) SWIG_fail;
8478 }
8479 resultobj = SWIG_From_double(static_cast< double >(result));
8480 return resultobj;
8481 fail:
8482 return NULL;
8483 }
8484
8485
8486 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8487 PyObject *resultobj = 0;
8488 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8489 wxPoint2D result;
8490 void *argp1 = 0 ;
8491 int res1 = 0 ;
8492 PyObject *swig_obj[1] ;
8493
8494 if (!args) SWIG_fail;
8495 swig_obj[0] = args;
8496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8497 if (!SWIG_IsOK(res1)) {
8498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8499 }
8500 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8501 {
8502 PyThreadState* __tstate = wxPyBeginAllowThreads();
8503 result = (arg1)->operator -();
8504 wxPyEndAllowThreads(__tstate);
8505 if (PyErr_Occurred()) SWIG_fail;
8506 }
8507 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8508 return resultobj;
8509 fail:
8510 return NULL;
8511 }
8512
8513
8514 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8515 PyObject *resultobj = 0;
8516 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8517 wxPoint2D *arg2 = 0 ;
8518 wxPoint2D *result = 0 ;
8519 void *argp1 = 0 ;
8520 int res1 = 0 ;
8521 wxPoint2D temp2 ;
8522 PyObject * obj0 = 0 ;
8523 PyObject * obj1 = 0 ;
8524 char * kwnames[] = {
8525 (char *) "self",(char *) "pt", NULL
8526 };
8527
8528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8530 if (!SWIG_IsOK(res1)) {
8531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8532 }
8533 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8534 {
8535 arg2 = &temp2;
8536 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8537 }
8538 {
8539 PyThreadState* __tstate = wxPyBeginAllowThreads();
8540 {
8541 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8542 result = (wxPoint2D *) &_result_ref;
8543 }
8544 wxPyEndAllowThreads(__tstate);
8545 if (PyErr_Occurred()) SWIG_fail;
8546 }
8547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8548 return resultobj;
8549 fail:
8550 return NULL;
8551 }
8552
8553
8554 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8555 PyObject *resultobj = 0;
8556 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8557 wxPoint2D *arg2 = 0 ;
8558 wxPoint2D *result = 0 ;
8559 void *argp1 = 0 ;
8560 int res1 = 0 ;
8561 wxPoint2D temp2 ;
8562 PyObject * obj0 = 0 ;
8563 PyObject * obj1 = 0 ;
8564 char * kwnames[] = {
8565 (char *) "self",(char *) "pt", NULL
8566 };
8567
8568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8570 if (!SWIG_IsOK(res1)) {
8571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8572 }
8573 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8574 {
8575 arg2 = &temp2;
8576 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8577 }
8578 {
8579 PyThreadState* __tstate = wxPyBeginAllowThreads();
8580 {
8581 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8582 result = (wxPoint2D *) &_result_ref;
8583 }
8584 wxPyEndAllowThreads(__tstate);
8585 if (PyErr_Occurred()) SWIG_fail;
8586 }
8587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8588 return resultobj;
8589 fail:
8590 return NULL;
8591 }
8592
8593
8594 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8595 PyObject *resultobj = 0;
8596 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8597 wxPoint2D *arg2 = 0 ;
8598 wxPoint2D *result = 0 ;
8599 void *argp1 = 0 ;
8600 int res1 = 0 ;
8601 wxPoint2D temp2 ;
8602 PyObject * obj0 = 0 ;
8603 PyObject * obj1 = 0 ;
8604 char * kwnames[] = {
8605 (char *) "self",(char *) "pt", NULL
8606 };
8607
8608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8610 if (!SWIG_IsOK(res1)) {
8611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8612 }
8613 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8614 {
8615 arg2 = &temp2;
8616 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8617 }
8618 {
8619 PyThreadState* __tstate = wxPyBeginAllowThreads();
8620 {
8621 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8622 result = (wxPoint2D *) &_result_ref;
8623 }
8624 wxPyEndAllowThreads(__tstate);
8625 if (PyErr_Occurred()) SWIG_fail;
8626 }
8627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8628 return resultobj;
8629 fail:
8630 return NULL;
8631 }
8632
8633
8634 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8635 PyObject *resultobj = 0;
8636 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8637 wxPoint2D *arg2 = 0 ;
8638 wxPoint2D *result = 0 ;
8639 void *argp1 = 0 ;
8640 int res1 = 0 ;
8641 wxPoint2D temp2 ;
8642 PyObject * obj0 = 0 ;
8643 PyObject * obj1 = 0 ;
8644 char * kwnames[] = {
8645 (char *) "self",(char *) "pt", NULL
8646 };
8647
8648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8650 if (!SWIG_IsOK(res1)) {
8651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8652 }
8653 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8654 {
8655 arg2 = &temp2;
8656 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8657 }
8658 {
8659 PyThreadState* __tstate = wxPyBeginAllowThreads();
8660 {
8661 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8662 result = (wxPoint2D *) &_result_ref;
8663 }
8664 wxPyEndAllowThreads(__tstate);
8665 if (PyErr_Occurred()) SWIG_fail;
8666 }
8667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8668 return resultobj;
8669 fail:
8670 return NULL;
8671 }
8672
8673
8674 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8675 PyObject *resultobj = 0;
8676 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8677 PyObject *arg2 = (PyObject *) 0 ;
8678 bool result;
8679 void *argp1 = 0 ;
8680 int res1 = 0 ;
8681 PyObject * obj0 = 0 ;
8682 PyObject * obj1 = 0 ;
8683 char * kwnames[] = {
8684 (char *) "self",(char *) "other", NULL
8685 };
8686
8687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8689 if (!SWIG_IsOK(res1)) {
8690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8691 }
8692 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8693 arg2 = obj1;
8694 {
8695 result = (bool)wxPoint2D___eq__(arg1,arg2);
8696 if (PyErr_Occurred()) SWIG_fail;
8697 }
8698 {
8699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8700 }
8701 return resultobj;
8702 fail:
8703 return NULL;
8704 }
8705
8706
8707 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8708 PyObject *resultobj = 0;
8709 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8710 PyObject *arg2 = (PyObject *) 0 ;
8711 bool result;
8712 void *argp1 = 0 ;
8713 int res1 = 0 ;
8714 PyObject * obj0 = 0 ;
8715 PyObject * obj1 = 0 ;
8716 char * kwnames[] = {
8717 (char *) "self",(char *) "other", NULL
8718 };
8719
8720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8722 if (!SWIG_IsOK(res1)) {
8723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8724 }
8725 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8726 arg2 = obj1;
8727 {
8728 result = (bool)wxPoint2D___ne__(arg1,arg2);
8729 if (PyErr_Occurred()) SWIG_fail;
8730 }
8731 {
8732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8733 }
8734 return resultobj;
8735 fail:
8736 return NULL;
8737 }
8738
8739
8740 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8741 PyObject *resultobj = 0;
8742 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8743 double arg2 ;
8744 void *argp1 = 0 ;
8745 int res1 = 0 ;
8746 double val2 ;
8747 int ecode2 = 0 ;
8748 PyObject *swig_obj[2] ;
8749
8750 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8752 if (!SWIG_IsOK(res1)) {
8753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8754 }
8755 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8756 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8757 if (!SWIG_IsOK(ecode2)) {
8758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8759 }
8760 arg2 = static_cast< double >(val2);
8761 if (arg1) (arg1)->m_x = arg2;
8762
8763 resultobj = SWIG_Py_Void();
8764 return resultobj;
8765 fail:
8766 return NULL;
8767 }
8768
8769
8770 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8771 PyObject *resultobj = 0;
8772 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8773 double result;
8774 void *argp1 = 0 ;
8775 int res1 = 0 ;
8776 PyObject *swig_obj[1] ;
8777
8778 if (!args) SWIG_fail;
8779 swig_obj[0] = args;
8780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8781 if (!SWIG_IsOK(res1)) {
8782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8783 }
8784 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8785 result = (double) ((arg1)->m_x);
8786 resultobj = SWIG_From_double(static_cast< double >(result));
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8794 PyObject *resultobj = 0;
8795 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8796 double arg2 ;
8797 void *argp1 = 0 ;
8798 int res1 = 0 ;
8799 double val2 ;
8800 int ecode2 = 0 ;
8801 PyObject *swig_obj[2] ;
8802
8803 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8805 if (!SWIG_IsOK(res1)) {
8806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8807 }
8808 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8809 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8810 if (!SWIG_IsOK(ecode2)) {
8811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8812 }
8813 arg2 = static_cast< double >(val2);
8814 if (arg1) (arg1)->m_y = arg2;
8815
8816 resultobj = SWIG_Py_Void();
8817 return resultobj;
8818 fail:
8819 return NULL;
8820 }
8821
8822
8823 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8824 PyObject *resultobj = 0;
8825 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8826 double result;
8827 void *argp1 = 0 ;
8828 int res1 = 0 ;
8829 PyObject *swig_obj[1] ;
8830
8831 if (!args) SWIG_fail;
8832 swig_obj[0] = args;
8833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8834 if (!SWIG_IsOK(res1)) {
8835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8836 }
8837 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8838 result = (double) ((arg1)->m_y);
8839 resultobj = SWIG_From_double(static_cast< double >(result));
8840 return resultobj;
8841 fail:
8842 return NULL;
8843 }
8844
8845
8846 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8847 PyObject *resultobj = 0;
8848 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8849 double arg2 = (double) 0 ;
8850 double arg3 = (double) 0 ;
8851 void *argp1 = 0 ;
8852 int res1 = 0 ;
8853 double val2 ;
8854 int ecode2 = 0 ;
8855 double val3 ;
8856 int ecode3 = 0 ;
8857 PyObject * obj0 = 0 ;
8858 PyObject * obj1 = 0 ;
8859 PyObject * obj2 = 0 ;
8860 char * kwnames[] = {
8861 (char *) "self",(char *) "x",(char *) "y", NULL
8862 };
8863
8864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8866 if (!SWIG_IsOK(res1)) {
8867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8868 }
8869 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8870 if (obj1) {
8871 ecode2 = SWIG_AsVal_double(obj1, &val2);
8872 if (!SWIG_IsOK(ecode2)) {
8873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8874 }
8875 arg2 = static_cast< double >(val2);
8876 }
8877 if (obj2) {
8878 ecode3 = SWIG_AsVal_double(obj2, &val3);
8879 if (!SWIG_IsOK(ecode3)) {
8880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8881 }
8882 arg3 = static_cast< double >(val3);
8883 }
8884 {
8885 PyThreadState* __tstate = wxPyBeginAllowThreads();
8886 wxPoint2D_Set(arg1,arg2,arg3);
8887 wxPyEndAllowThreads(__tstate);
8888 if (PyErr_Occurred()) SWIG_fail;
8889 }
8890 resultobj = SWIG_Py_Void();
8891 return resultobj;
8892 fail:
8893 return NULL;
8894 }
8895
8896
8897 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8898 PyObject *resultobj = 0;
8899 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8900 PyObject *result = 0 ;
8901 void *argp1 = 0 ;
8902 int res1 = 0 ;
8903 PyObject *swig_obj[1] ;
8904
8905 if (!args) SWIG_fail;
8906 swig_obj[0] = args;
8907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8908 if (!SWIG_IsOK(res1)) {
8909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8910 }
8911 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8912 {
8913 PyThreadState* __tstate = wxPyBeginAllowThreads();
8914 result = (PyObject *)wxPoint2D_Get(arg1);
8915 wxPyEndAllowThreads(__tstate);
8916 if (PyErr_Occurred()) SWIG_fail;
8917 }
8918 resultobj = result;
8919 return resultobj;
8920 fail:
8921 return NULL;
8922 }
8923
8924
8925 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8926 PyObject *obj;
8927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8928 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8929 return SWIG_Py_Void();
8930 }
8931
8932 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8933 return SWIG_Python_InitShadowInstance(args);
8934 }
8935
8936 SWIGINTERN int DefaultPosition_set(PyObject *) {
8937 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8938 return 1;
8939 }
8940
8941
8942 SWIGINTERN PyObject *DefaultPosition_get(void) {
8943 PyObject *pyobj = 0;
8944
8945 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8946 return pyobj;
8947 }
8948
8949
8950 SWIGINTERN int DefaultSize_set(PyObject *) {
8951 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8952 return 1;
8953 }
8954
8955
8956 SWIGINTERN PyObject *DefaultSize_get(void) {
8957 PyObject *pyobj = 0;
8958
8959 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8960 return pyobj;
8961 }
8962
8963
8964 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8965 PyObject *resultobj = 0;
8966 PyObject *arg1 = (PyObject *) 0 ;
8967 wxPyInputStream *result = 0 ;
8968 PyObject * obj0 = 0 ;
8969 char * kwnames[] = {
8970 (char *) "p", NULL
8971 };
8972
8973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8974 arg1 = obj0;
8975 {
8976 PyThreadState* __tstate = wxPyBeginAllowThreads();
8977 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8978 wxPyEndAllowThreads(__tstate);
8979 if (PyErr_Occurred()) SWIG_fail;
8980 }
8981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8982 return resultobj;
8983 fail:
8984 return NULL;
8985 }
8986
8987
8988 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8989 PyObject *resultobj = 0;
8990 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8991 void *argp1 = 0 ;
8992 int res1 = 0 ;
8993 PyObject *swig_obj[1] ;
8994
8995 if (!args) SWIG_fail;
8996 swig_obj[0] = args;
8997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8998 if (!SWIG_IsOK(res1)) {
8999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9000 }
9001 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9002 {
9003 PyThreadState* __tstate = wxPyBeginAllowThreads();
9004 delete arg1;
9005
9006 wxPyEndAllowThreads(__tstate);
9007 if (PyErr_Occurred()) SWIG_fail;
9008 }
9009 resultobj = SWIG_Py_Void();
9010 return resultobj;
9011 fail:
9012 return NULL;
9013 }
9014
9015
9016 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9017 PyObject *resultobj = 0;
9018 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9019 void *argp1 = 0 ;
9020 int res1 = 0 ;
9021 PyObject *swig_obj[1] ;
9022
9023 if (!args) SWIG_fail;
9024 swig_obj[0] = args;
9025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9026 if (!SWIG_IsOK(res1)) {
9027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9028 }
9029 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9030 {
9031 PyThreadState* __tstate = wxPyBeginAllowThreads();
9032 (arg1)->close();
9033 wxPyEndAllowThreads(__tstate);
9034 if (PyErr_Occurred()) SWIG_fail;
9035 }
9036 resultobj = SWIG_Py_Void();
9037 return resultobj;
9038 fail:
9039 return NULL;
9040 }
9041
9042
9043 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9044 PyObject *resultobj = 0;
9045 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9046 void *argp1 = 0 ;
9047 int res1 = 0 ;
9048 PyObject *swig_obj[1] ;
9049
9050 if (!args) SWIG_fail;
9051 swig_obj[0] = args;
9052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9053 if (!SWIG_IsOK(res1)) {
9054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9055 }
9056 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9057 {
9058 PyThreadState* __tstate = wxPyBeginAllowThreads();
9059 (arg1)->flush();
9060 wxPyEndAllowThreads(__tstate);
9061 if (PyErr_Occurred()) SWIG_fail;
9062 }
9063 resultobj = SWIG_Py_Void();
9064 return resultobj;
9065 fail:
9066 return NULL;
9067 }
9068
9069
9070 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9071 PyObject *resultobj = 0;
9072 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9073 bool result;
9074 void *argp1 = 0 ;
9075 int res1 = 0 ;
9076 PyObject *swig_obj[1] ;
9077
9078 if (!args) SWIG_fail;
9079 swig_obj[0] = args;
9080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9081 if (!SWIG_IsOK(res1)) {
9082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9083 }
9084 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9085 {
9086 PyThreadState* __tstate = wxPyBeginAllowThreads();
9087 result = (bool)(arg1)->eof();
9088 wxPyEndAllowThreads(__tstate);
9089 if (PyErr_Occurred()) SWIG_fail;
9090 }
9091 {
9092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9093 }
9094 return resultobj;
9095 fail:
9096 return NULL;
9097 }
9098
9099
9100 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9101 PyObject *resultobj = 0;
9102 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9103 int arg2 = (int) -1 ;
9104 PyObject *result = 0 ;
9105 void *argp1 = 0 ;
9106 int res1 = 0 ;
9107 int val2 ;
9108 int ecode2 = 0 ;
9109 PyObject * obj0 = 0 ;
9110 PyObject * obj1 = 0 ;
9111 char * kwnames[] = {
9112 (char *) "self",(char *) "size", NULL
9113 };
9114
9115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9117 if (!SWIG_IsOK(res1)) {
9118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9119 }
9120 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9121 if (obj1) {
9122 ecode2 = SWIG_AsVal_int(obj1, &val2);
9123 if (!SWIG_IsOK(ecode2)) {
9124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9125 }
9126 arg2 = static_cast< int >(val2);
9127 }
9128 {
9129 PyThreadState* __tstate = wxPyBeginAllowThreads();
9130 result = (PyObject *)(arg1)->read(arg2);
9131 wxPyEndAllowThreads(__tstate);
9132 if (PyErr_Occurred()) SWIG_fail;
9133 }
9134 resultobj = result;
9135 return resultobj;
9136 fail:
9137 return NULL;
9138 }
9139
9140
9141 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9142 PyObject *resultobj = 0;
9143 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9144 int arg2 = (int) -1 ;
9145 PyObject *result = 0 ;
9146 void *argp1 = 0 ;
9147 int res1 = 0 ;
9148 int val2 ;
9149 int ecode2 = 0 ;
9150 PyObject * obj0 = 0 ;
9151 PyObject * obj1 = 0 ;
9152 char * kwnames[] = {
9153 (char *) "self",(char *) "size", NULL
9154 };
9155
9156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9158 if (!SWIG_IsOK(res1)) {
9159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9160 }
9161 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9162 if (obj1) {
9163 ecode2 = SWIG_AsVal_int(obj1, &val2);
9164 if (!SWIG_IsOK(ecode2)) {
9165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9166 }
9167 arg2 = static_cast< int >(val2);
9168 }
9169 {
9170 PyThreadState* __tstate = wxPyBeginAllowThreads();
9171 result = (PyObject *)(arg1)->readline(arg2);
9172 wxPyEndAllowThreads(__tstate);
9173 if (PyErr_Occurred()) SWIG_fail;
9174 }
9175 resultobj = result;
9176 return resultobj;
9177 fail:
9178 return NULL;
9179 }
9180
9181
9182 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9183 PyObject *resultobj = 0;
9184 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9185 int arg2 = (int) -1 ;
9186 PyObject *result = 0 ;
9187 void *argp1 = 0 ;
9188 int res1 = 0 ;
9189 int val2 ;
9190 int ecode2 = 0 ;
9191 PyObject * obj0 = 0 ;
9192 PyObject * obj1 = 0 ;
9193 char * kwnames[] = {
9194 (char *) "self",(char *) "sizehint", NULL
9195 };
9196
9197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9199 if (!SWIG_IsOK(res1)) {
9200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9201 }
9202 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9203 if (obj1) {
9204 ecode2 = SWIG_AsVal_int(obj1, &val2);
9205 if (!SWIG_IsOK(ecode2)) {
9206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9207 }
9208 arg2 = static_cast< int >(val2);
9209 }
9210 {
9211 PyThreadState* __tstate = wxPyBeginAllowThreads();
9212 result = (PyObject *)(arg1)->readlines(arg2);
9213 wxPyEndAllowThreads(__tstate);
9214 if (PyErr_Occurred()) SWIG_fail;
9215 }
9216 resultobj = result;
9217 return resultobj;
9218 fail:
9219 return NULL;
9220 }
9221
9222
9223 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9224 PyObject *resultobj = 0;
9225 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9226 int arg2 ;
9227 int arg3 = (int) 0 ;
9228 void *argp1 = 0 ;
9229 int res1 = 0 ;
9230 int val2 ;
9231 int ecode2 = 0 ;
9232 int val3 ;
9233 int ecode3 = 0 ;
9234 PyObject * obj0 = 0 ;
9235 PyObject * obj1 = 0 ;
9236 PyObject * obj2 = 0 ;
9237 char * kwnames[] = {
9238 (char *) "self",(char *) "offset",(char *) "whence", NULL
9239 };
9240
9241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9243 if (!SWIG_IsOK(res1)) {
9244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9245 }
9246 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9247 ecode2 = SWIG_AsVal_int(obj1, &val2);
9248 if (!SWIG_IsOK(ecode2)) {
9249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9250 }
9251 arg2 = static_cast< int >(val2);
9252 if (obj2) {
9253 ecode3 = SWIG_AsVal_int(obj2, &val3);
9254 if (!SWIG_IsOK(ecode3)) {
9255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9256 }
9257 arg3 = static_cast< int >(val3);
9258 }
9259 {
9260 PyThreadState* __tstate = wxPyBeginAllowThreads();
9261 (arg1)->seek(arg2,arg3);
9262 wxPyEndAllowThreads(__tstate);
9263 if (PyErr_Occurred()) SWIG_fail;
9264 }
9265 resultobj = SWIG_Py_Void();
9266 return resultobj;
9267 fail:
9268 return NULL;
9269 }
9270
9271
9272 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9273 PyObject *resultobj = 0;
9274 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9275 int result;
9276 void *argp1 = 0 ;
9277 int res1 = 0 ;
9278 PyObject *swig_obj[1] ;
9279
9280 if (!args) SWIG_fail;
9281 swig_obj[0] = args;
9282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9283 if (!SWIG_IsOK(res1)) {
9284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9285 }
9286 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9287 {
9288 PyThreadState* __tstate = wxPyBeginAllowThreads();
9289 result = (int)(arg1)->tell();
9290 wxPyEndAllowThreads(__tstate);
9291 if (PyErr_Occurred()) SWIG_fail;
9292 }
9293 resultobj = SWIG_From_int(static_cast< int >(result));
9294 return resultobj;
9295 fail:
9296 return NULL;
9297 }
9298
9299
9300 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9301 PyObject *resultobj = 0;
9302 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9303 char result;
9304 void *argp1 = 0 ;
9305 int res1 = 0 ;
9306 PyObject *swig_obj[1] ;
9307
9308 if (!args) SWIG_fail;
9309 swig_obj[0] = args;
9310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9311 if (!SWIG_IsOK(res1)) {
9312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9313 }
9314 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9315 {
9316 PyThreadState* __tstate = wxPyBeginAllowThreads();
9317 result = (char)(arg1)->Peek();
9318 wxPyEndAllowThreads(__tstate);
9319 if (PyErr_Occurred()) SWIG_fail;
9320 }
9321 resultobj = SWIG_From_char(static_cast< char >(result));
9322 return resultobj;
9323 fail:
9324 return NULL;
9325 }
9326
9327
9328 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9329 PyObject *resultobj = 0;
9330 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9331 char result;
9332 void *argp1 = 0 ;
9333 int res1 = 0 ;
9334 PyObject *swig_obj[1] ;
9335
9336 if (!args) SWIG_fail;
9337 swig_obj[0] = args;
9338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9339 if (!SWIG_IsOK(res1)) {
9340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9341 }
9342 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9343 {
9344 PyThreadState* __tstate = wxPyBeginAllowThreads();
9345 result = (char)(arg1)->GetC();
9346 wxPyEndAllowThreads(__tstate);
9347 if (PyErr_Occurred()) SWIG_fail;
9348 }
9349 resultobj = SWIG_From_char(static_cast< char >(result));
9350 return resultobj;
9351 fail:
9352 return NULL;
9353 }
9354
9355
9356 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9357 PyObject *resultobj = 0;
9358 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9359 size_t result;
9360 void *argp1 = 0 ;
9361 int res1 = 0 ;
9362 PyObject *swig_obj[1] ;
9363
9364 if (!args) SWIG_fail;
9365 swig_obj[0] = args;
9366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9367 if (!SWIG_IsOK(res1)) {
9368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9369 }
9370 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9371 {
9372 PyThreadState* __tstate = wxPyBeginAllowThreads();
9373 result = (size_t)(arg1)->LastRead();
9374 wxPyEndAllowThreads(__tstate);
9375 if (PyErr_Occurred()) SWIG_fail;
9376 }
9377 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9378 return resultobj;
9379 fail:
9380 return NULL;
9381 }
9382
9383
9384 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9385 PyObject *resultobj = 0;
9386 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9387 bool result;
9388 void *argp1 = 0 ;
9389 int res1 = 0 ;
9390 PyObject *swig_obj[1] ;
9391
9392 if (!args) SWIG_fail;
9393 swig_obj[0] = args;
9394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9395 if (!SWIG_IsOK(res1)) {
9396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9397 }
9398 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9399 {
9400 PyThreadState* __tstate = wxPyBeginAllowThreads();
9401 result = (bool)(arg1)->CanRead();
9402 wxPyEndAllowThreads(__tstate);
9403 if (PyErr_Occurred()) SWIG_fail;
9404 }
9405 {
9406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9407 }
9408 return resultobj;
9409 fail:
9410 return NULL;
9411 }
9412
9413
9414 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9415 PyObject *resultobj = 0;
9416 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9417 bool result;
9418 void *argp1 = 0 ;
9419 int res1 = 0 ;
9420 PyObject *swig_obj[1] ;
9421
9422 if (!args) SWIG_fail;
9423 swig_obj[0] = args;
9424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9425 if (!SWIG_IsOK(res1)) {
9426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9427 }
9428 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9429 {
9430 PyThreadState* __tstate = wxPyBeginAllowThreads();
9431 result = (bool)(arg1)->Eof();
9432 wxPyEndAllowThreads(__tstate);
9433 if (PyErr_Occurred()) SWIG_fail;
9434 }
9435 {
9436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9437 }
9438 return resultobj;
9439 fail:
9440 return NULL;
9441 }
9442
9443
9444 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9445 PyObject *resultobj = 0;
9446 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9447 char arg2 ;
9448 bool result;
9449 void *argp1 = 0 ;
9450 int res1 = 0 ;
9451 char val2 ;
9452 int ecode2 = 0 ;
9453 PyObject * obj0 = 0 ;
9454 PyObject * obj1 = 0 ;
9455 char * kwnames[] = {
9456 (char *) "self",(char *) "c", NULL
9457 };
9458
9459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9461 if (!SWIG_IsOK(res1)) {
9462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9463 }
9464 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9465 ecode2 = SWIG_AsVal_char(obj1, &val2);
9466 if (!SWIG_IsOK(ecode2)) {
9467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9468 }
9469 arg2 = static_cast< char >(val2);
9470 {
9471 PyThreadState* __tstate = wxPyBeginAllowThreads();
9472 result = (bool)(arg1)->Ungetch(arg2);
9473 wxPyEndAllowThreads(__tstate);
9474 if (PyErr_Occurred()) SWIG_fail;
9475 }
9476 {
9477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9478 }
9479 return resultobj;
9480 fail:
9481 return NULL;
9482 }
9483
9484
9485 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9486 PyObject *resultobj = 0;
9487 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9488 long arg2 ;
9489 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9490 long result;
9491 void *argp1 = 0 ;
9492 int res1 = 0 ;
9493 long val2 ;
9494 int ecode2 = 0 ;
9495 int val3 ;
9496 int ecode3 = 0 ;
9497 PyObject * obj0 = 0 ;
9498 PyObject * obj1 = 0 ;
9499 PyObject * obj2 = 0 ;
9500 char * kwnames[] = {
9501 (char *) "self",(char *) "pos",(char *) "mode", NULL
9502 };
9503
9504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9506 if (!SWIG_IsOK(res1)) {
9507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9508 }
9509 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9510 ecode2 = SWIG_AsVal_long(obj1, &val2);
9511 if (!SWIG_IsOK(ecode2)) {
9512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9513 }
9514 arg2 = static_cast< long >(val2);
9515 if (obj2) {
9516 ecode3 = SWIG_AsVal_int(obj2, &val3);
9517 if (!SWIG_IsOK(ecode3)) {
9518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9519 }
9520 arg3 = static_cast< wxSeekMode >(val3);
9521 }
9522 {
9523 PyThreadState* __tstate = wxPyBeginAllowThreads();
9524 result = (long)(arg1)->SeekI(arg2,arg3);
9525 wxPyEndAllowThreads(__tstate);
9526 if (PyErr_Occurred()) SWIG_fail;
9527 }
9528 resultobj = SWIG_From_long(static_cast< long >(result));
9529 return resultobj;
9530 fail:
9531 return NULL;
9532 }
9533
9534
9535 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9536 PyObject *resultobj = 0;
9537 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9538 long result;
9539 void *argp1 = 0 ;
9540 int res1 = 0 ;
9541 PyObject *swig_obj[1] ;
9542
9543 if (!args) SWIG_fail;
9544 swig_obj[0] = args;
9545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9546 if (!SWIG_IsOK(res1)) {
9547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9548 }
9549 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9550 {
9551 PyThreadState* __tstate = wxPyBeginAllowThreads();
9552 result = (long)(arg1)->TellI();
9553 wxPyEndAllowThreads(__tstate);
9554 if (PyErr_Occurred()) SWIG_fail;
9555 }
9556 resultobj = SWIG_From_long(static_cast< long >(result));
9557 return resultobj;
9558 fail:
9559 return NULL;
9560 }
9561
9562
9563 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9564 PyObject *obj;
9565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9566 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9567 return SWIG_Py_Void();
9568 }
9569
9570 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9571 return SWIG_Python_InitShadowInstance(args);
9572 }
9573
9574 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9575 PyObject *resultobj = 0;
9576 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9577 PyObject *arg2 = (PyObject *) 0 ;
9578 void *argp1 = 0 ;
9579 int res1 = 0 ;
9580 PyObject * obj0 = 0 ;
9581 PyObject * obj1 = 0 ;
9582 char * kwnames[] = {
9583 (char *) "self",(char *) "obj", NULL
9584 };
9585
9586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9588 if (!SWIG_IsOK(res1)) {
9589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9590 }
9591 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9592 arg2 = obj1;
9593 {
9594 PyThreadState* __tstate = wxPyBeginAllowThreads();
9595 wxOutputStream_write(arg1,arg2);
9596 wxPyEndAllowThreads(__tstate);
9597 if (PyErr_Occurred()) SWIG_fail;
9598 }
9599 resultobj = SWIG_Py_Void();
9600 return resultobj;
9601 fail:
9602 return NULL;
9603 }
9604
9605
9606 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9607 PyObject *resultobj = 0;
9608 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9609 size_t result;
9610 void *argp1 = 0 ;
9611 int res1 = 0 ;
9612 PyObject *swig_obj[1] ;
9613
9614 if (!args) SWIG_fail;
9615 swig_obj[0] = args;
9616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9617 if (!SWIG_IsOK(res1)) {
9618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9619 }
9620 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9621 {
9622 PyThreadState* __tstate = wxPyBeginAllowThreads();
9623 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9624 wxPyEndAllowThreads(__tstate);
9625 if (PyErr_Occurred()) SWIG_fail;
9626 }
9627 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9628 return resultobj;
9629 fail:
9630 return NULL;
9631 }
9632
9633
9634 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9635 PyObject *obj;
9636 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9637 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9638 return SWIG_Py_Void();
9639 }
9640
9641 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9642 PyObject *resultobj = 0;
9643 wxInputStream *arg1 = (wxInputStream *) 0 ;
9644 wxString *arg2 = 0 ;
9645 wxString *arg3 = 0 ;
9646 wxString *arg4 = 0 ;
9647 wxDateTime arg5 ;
9648 wxFSFile *result = 0 ;
9649 wxPyInputStream *temp1 ;
9650 bool temp2 = false ;
9651 bool temp3 = false ;
9652 bool temp4 = false ;
9653 void *argp5 ;
9654 int res5 = 0 ;
9655 PyObject * obj0 = 0 ;
9656 PyObject * obj1 = 0 ;
9657 PyObject * obj2 = 0 ;
9658 PyObject * obj3 = 0 ;
9659 PyObject * obj4 = 0 ;
9660 char * kwnames[] = {
9661 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9662 };
9663
9664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9665 {
9666 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9667 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9668 } else {
9669 PyErr_Clear(); // clear the failure of the wxPyConvert above
9670 arg1 = wxPyCBInputStream_create(obj0, true);
9671 if (arg1 == NULL) {
9672 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9673 SWIG_fail;
9674 }
9675 }
9676 }
9677 {
9678 arg2 = wxString_in_helper(obj1);
9679 if (arg2 == NULL) SWIG_fail;
9680 temp2 = true;
9681 }
9682 {
9683 arg3 = wxString_in_helper(obj2);
9684 if (arg3 == NULL) SWIG_fail;
9685 temp3 = true;
9686 }
9687 {
9688 arg4 = wxString_in_helper(obj3);
9689 if (arg4 == NULL) SWIG_fail;
9690 temp4 = true;
9691 }
9692 {
9693 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9694 if (!SWIG_IsOK(res5)) {
9695 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9696 }
9697 if (!argp5) {
9698 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9699 } else {
9700 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9701 arg5 = *temp;
9702 if (SWIG_IsNewObj(res5)) delete temp;
9703 }
9704 }
9705 {
9706 PyThreadState* __tstate = wxPyBeginAllowThreads();
9707 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9708 wxPyEndAllowThreads(__tstate);
9709 if (PyErr_Occurred()) SWIG_fail;
9710 }
9711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9712 {
9713 if (temp2)
9714 delete arg2;
9715 }
9716 {
9717 if (temp3)
9718 delete arg3;
9719 }
9720 {
9721 if (temp4)
9722 delete arg4;
9723 }
9724 return resultobj;
9725 fail:
9726 {
9727 if (temp2)
9728 delete arg2;
9729 }
9730 {
9731 if (temp3)
9732 delete arg3;
9733 }
9734 {
9735 if (temp4)
9736 delete arg4;
9737 }
9738 return NULL;
9739 }
9740
9741
9742 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9743 PyObject *resultobj = 0;
9744 wxFSFile *arg1 = (wxFSFile *) 0 ;
9745 void *argp1 = 0 ;
9746 int res1 = 0 ;
9747 PyObject *swig_obj[1] ;
9748
9749 if (!args) SWIG_fail;
9750 swig_obj[0] = args;
9751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9752 if (!SWIG_IsOK(res1)) {
9753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9754 }
9755 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9756 {
9757 PyThreadState* __tstate = wxPyBeginAllowThreads();
9758 delete arg1;
9759
9760 wxPyEndAllowThreads(__tstate);
9761 if (PyErr_Occurred()) SWIG_fail;
9762 }
9763 resultobj = SWIG_Py_Void();
9764 return resultobj;
9765 fail:
9766 return NULL;
9767 }
9768
9769
9770 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9771 PyObject *resultobj = 0;
9772 wxFSFile *arg1 = (wxFSFile *) 0 ;
9773 wxInputStream *result = 0 ;
9774 void *argp1 = 0 ;
9775 int res1 = 0 ;
9776 PyObject *swig_obj[1] ;
9777
9778 if (!args) SWIG_fail;
9779 swig_obj[0] = args;
9780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9781 if (!SWIG_IsOK(res1)) {
9782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9783 }
9784 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9785 {
9786 PyThreadState* __tstate = wxPyBeginAllowThreads();
9787 result = (wxInputStream *)(arg1)->GetStream();
9788 wxPyEndAllowThreads(__tstate);
9789 if (PyErr_Occurred()) SWIG_fail;
9790 }
9791 {
9792 wxPyInputStream * _ptr = NULL;
9793
9794 if (result) {
9795 _ptr = new wxPyInputStream(result);
9796 }
9797 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9798 }
9799 return resultobj;
9800 fail:
9801 return NULL;
9802 }
9803
9804
9805 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9806 PyObject *resultobj = 0;
9807 wxFSFile *arg1 = (wxFSFile *) 0 ;
9808 wxString *result = 0 ;
9809 void *argp1 = 0 ;
9810 int res1 = 0 ;
9811 PyObject *swig_obj[1] ;
9812
9813 if (!args) SWIG_fail;
9814 swig_obj[0] = args;
9815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9816 if (!SWIG_IsOK(res1)) {
9817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9818 }
9819 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9820 {
9821 PyThreadState* __tstate = wxPyBeginAllowThreads();
9822 {
9823 wxString const &_result_ref = (arg1)->GetMimeType();
9824 result = (wxString *) &_result_ref;
9825 }
9826 wxPyEndAllowThreads(__tstate);
9827 if (PyErr_Occurred()) SWIG_fail;
9828 }
9829 {
9830 #if wxUSE_UNICODE
9831 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9832 #else
9833 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9834 #endif
9835 }
9836 return resultobj;
9837 fail:
9838 return NULL;
9839 }
9840
9841
9842 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9843 PyObject *resultobj = 0;
9844 wxFSFile *arg1 = (wxFSFile *) 0 ;
9845 wxString *result = 0 ;
9846 void *argp1 = 0 ;
9847 int res1 = 0 ;
9848 PyObject *swig_obj[1] ;
9849
9850 if (!args) SWIG_fail;
9851 swig_obj[0] = args;
9852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9853 if (!SWIG_IsOK(res1)) {
9854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9855 }
9856 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9857 {
9858 PyThreadState* __tstate = wxPyBeginAllowThreads();
9859 {
9860 wxString const &_result_ref = (arg1)->GetLocation();
9861 result = (wxString *) &_result_ref;
9862 }
9863 wxPyEndAllowThreads(__tstate);
9864 if (PyErr_Occurred()) SWIG_fail;
9865 }
9866 {
9867 #if wxUSE_UNICODE
9868 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9869 #else
9870 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9871 #endif
9872 }
9873 return resultobj;
9874 fail:
9875 return NULL;
9876 }
9877
9878
9879 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9880 PyObject *resultobj = 0;
9881 wxFSFile *arg1 = (wxFSFile *) 0 ;
9882 wxString *result = 0 ;
9883 void *argp1 = 0 ;
9884 int res1 = 0 ;
9885 PyObject *swig_obj[1] ;
9886
9887 if (!args) SWIG_fail;
9888 swig_obj[0] = args;
9889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9890 if (!SWIG_IsOK(res1)) {
9891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9892 }
9893 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9894 {
9895 PyThreadState* __tstate = wxPyBeginAllowThreads();
9896 {
9897 wxString const &_result_ref = (arg1)->GetAnchor();
9898 result = (wxString *) &_result_ref;
9899 }
9900 wxPyEndAllowThreads(__tstate);
9901 if (PyErr_Occurred()) SWIG_fail;
9902 }
9903 {
9904 #if wxUSE_UNICODE
9905 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9906 #else
9907 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9908 #endif
9909 }
9910 return resultobj;
9911 fail:
9912 return NULL;
9913 }
9914
9915
9916 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9917 PyObject *resultobj = 0;
9918 wxFSFile *arg1 = (wxFSFile *) 0 ;
9919 wxDateTime result;
9920 void *argp1 = 0 ;
9921 int res1 = 0 ;
9922 PyObject *swig_obj[1] ;
9923
9924 if (!args) SWIG_fail;
9925 swig_obj[0] = args;
9926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9927 if (!SWIG_IsOK(res1)) {
9928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9929 }
9930 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9931 {
9932 PyThreadState* __tstate = wxPyBeginAllowThreads();
9933 result = (arg1)->GetModificationTime();
9934 wxPyEndAllowThreads(__tstate);
9935 if (PyErr_Occurred()) SWIG_fail;
9936 }
9937 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9938 return resultobj;
9939 fail:
9940 return NULL;
9941 }
9942
9943
9944 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9945 PyObject *obj;
9946 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9947 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9948 return SWIG_Py_Void();
9949 }
9950
9951 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9952 return SWIG_Python_InitShadowInstance(args);
9953 }
9954
9955 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9956 PyObject *resultobj = 0;
9957 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9958 void *argp1 = 0 ;
9959 int res1 = 0 ;
9960 PyObject *swig_obj[1] ;
9961
9962 if (!args) SWIG_fail;
9963 swig_obj[0] = args;
9964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9965 if (!SWIG_IsOK(res1)) {
9966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9967 }
9968 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9969 {
9970 PyThreadState* __tstate = wxPyBeginAllowThreads();
9971 delete arg1;
9972
9973 wxPyEndAllowThreads(__tstate);
9974 if (PyErr_Occurred()) SWIG_fail;
9975 }
9976 resultobj = SWIG_Py_Void();
9977 return resultobj;
9978 fail:
9979 return NULL;
9980 }
9981
9982
9983 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9984 PyObject *obj;
9985 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9986 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9987 return SWIG_Py_Void();
9988 }
9989
9990 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9991 PyObject *resultobj = 0;
9992 wxPyFileSystemHandler *result = 0 ;
9993
9994 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9995 {
9996 PyThreadState* __tstate = wxPyBeginAllowThreads();
9997 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9998 wxPyEndAllowThreads(__tstate);
9999 if (PyErr_Occurred()) SWIG_fail;
10000 }
10001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10002 return resultobj;
10003 fail:
10004 return NULL;
10005 }
10006
10007
10008 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10009 PyObject *resultobj = 0;
10010 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10011 PyObject *arg2 = (PyObject *) 0 ;
10012 PyObject *arg3 = (PyObject *) 0 ;
10013 void *argp1 = 0 ;
10014 int res1 = 0 ;
10015 PyObject * obj0 = 0 ;
10016 PyObject * obj1 = 0 ;
10017 PyObject * obj2 = 0 ;
10018 char * kwnames[] = {
10019 (char *) "self",(char *) "self",(char *) "_class", NULL
10020 };
10021
10022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10024 if (!SWIG_IsOK(res1)) {
10025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10026 }
10027 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10028 arg2 = obj1;
10029 arg3 = obj2;
10030 {
10031 PyThreadState* __tstate = wxPyBeginAllowThreads();
10032 (arg1)->_setCallbackInfo(arg2,arg3);
10033 wxPyEndAllowThreads(__tstate);
10034 if (PyErr_Occurred()) SWIG_fail;
10035 }
10036 resultobj = SWIG_Py_Void();
10037 return resultobj;
10038 fail:
10039 return NULL;
10040 }
10041
10042
10043 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10044 PyObject *resultobj = 0;
10045 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10046 wxString *arg2 = 0 ;
10047 bool result;
10048 void *argp1 = 0 ;
10049 int res1 = 0 ;
10050 bool temp2 = false ;
10051 PyObject * obj0 = 0 ;
10052 PyObject * obj1 = 0 ;
10053 char * kwnames[] = {
10054 (char *) "self",(char *) "location", NULL
10055 };
10056
10057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10059 if (!SWIG_IsOK(res1)) {
10060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10061 }
10062 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10063 {
10064 arg2 = wxString_in_helper(obj1);
10065 if (arg2 == NULL) SWIG_fail;
10066 temp2 = true;
10067 }
10068 {
10069 PyThreadState* __tstate = wxPyBeginAllowThreads();
10070 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10071 wxPyEndAllowThreads(__tstate);
10072 if (PyErr_Occurred()) SWIG_fail;
10073 }
10074 {
10075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10076 }
10077 {
10078 if (temp2)
10079 delete arg2;
10080 }
10081 return resultobj;
10082 fail:
10083 {
10084 if (temp2)
10085 delete arg2;
10086 }
10087 return NULL;
10088 }
10089
10090
10091 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10092 PyObject *resultobj = 0;
10093 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10094 wxFileSystem *arg2 = 0 ;
10095 wxString *arg3 = 0 ;
10096 wxFSFile *result = 0 ;
10097 void *argp1 = 0 ;
10098 int res1 = 0 ;
10099 void *argp2 = 0 ;
10100 int res2 = 0 ;
10101 bool temp3 = false ;
10102 PyObject * obj0 = 0 ;
10103 PyObject * obj1 = 0 ;
10104 PyObject * obj2 = 0 ;
10105 char * kwnames[] = {
10106 (char *) "self",(char *) "fs",(char *) "location", NULL
10107 };
10108
10109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10111 if (!SWIG_IsOK(res1)) {
10112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10113 }
10114 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10115 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10116 if (!SWIG_IsOK(res2)) {
10117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10118 }
10119 if (!argp2) {
10120 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10121 }
10122 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10123 {
10124 arg3 = wxString_in_helper(obj2);
10125 if (arg3 == NULL) SWIG_fail;
10126 temp3 = true;
10127 }
10128 {
10129 PyThreadState* __tstate = wxPyBeginAllowThreads();
10130 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10131 wxPyEndAllowThreads(__tstate);
10132 if (PyErr_Occurred()) SWIG_fail;
10133 }
10134 {
10135 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10136 }
10137 {
10138 if (temp3)
10139 delete arg3;
10140 }
10141 return resultobj;
10142 fail:
10143 {
10144 if (temp3)
10145 delete arg3;
10146 }
10147 return NULL;
10148 }
10149
10150
10151 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10152 PyObject *resultobj = 0;
10153 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10154 wxString *arg2 = 0 ;
10155 int arg3 = (int) 0 ;
10156 wxString result;
10157 void *argp1 = 0 ;
10158 int res1 = 0 ;
10159 bool temp2 = false ;
10160 int val3 ;
10161 int ecode3 = 0 ;
10162 PyObject * obj0 = 0 ;
10163 PyObject * obj1 = 0 ;
10164 PyObject * obj2 = 0 ;
10165 char * kwnames[] = {
10166 (char *) "self",(char *) "spec",(char *) "flags", NULL
10167 };
10168
10169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10171 if (!SWIG_IsOK(res1)) {
10172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10173 }
10174 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10175 {
10176 arg2 = wxString_in_helper(obj1);
10177 if (arg2 == NULL) SWIG_fail;
10178 temp2 = true;
10179 }
10180 if (obj2) {
10181 ecode3 = SWIG_AsVal_int(obj2, &val3);
10182 if (!SWIG_IsOK(ecode3)) {
10183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10184 }
10185 arg3 = static_cast< int >(val3);
10186 }
10187 {
10188 PyThreadState* __tstate = wxPyBeginAllowThreads();
10189 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10190 wxPyEndAllowThreads(__tstate);
10191 if (PyErr_Occurred()) SWIG_fail;
10192 }
10193 {
10194 #if wxUSE_UNICODE
10195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10196 #else
10197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10198 #endif
10199 }
10200 {
10201 if (temp2)
10202 delete arg2;
10203 }
10204 return resultobj;
10205 fail:
10206 {
10207 if (temp2)
10208 delete arg2;
10209 }
10210 return NULL;
10211 }
10212
10213
10214 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10215 PyObject *resultobj = 0;
10216 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10217 wxString result;
10218 void *argp1 = 0 ;
10219 int res1 = 0 ;
10220 PyObject *swig_obj[1] ;
10221
10222 if (!args) SWIG_fail;
10223 swig_obj[0] = args;
10224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10225 if (!SWIG_IsOK(res1)) {
10226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10227 }
10228 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10229 {
10230 PyThreadState* __tstate = wxPyBeginAllowThreads();
10231 result = (arg1)->FindNext();
10232 wxPyEndAllowThreads(__tstate);
10233 if (PyErr_Occurred()) SWIG_fail;
10234 }
10235 {
10236 #if wxUSE_UNICODE
10237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10238 #else
10239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10240 #endif
10241 }
10242 return resultobj;
10243 fail:
10244 return NULL;
10245 }
10246
10247
10248 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10249 PyObject *resultobj = 0;
10250 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10251 wxString *arg2 = 0 ;
10252 wxString result;
10253 void *argp1 = 0 ;
10254 int res1 = 0 ;
10255 bool temp2 = false ;
10256 PyObject * obj0 = 0 ;
10257 PyObject * obj1 = 0 ;
10258 char * kwnames[] = {
10259 (char *) "self",(char *) "location", NULL
10260 };
10261
10262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10264 if (!SWIG_IsOK(res1)) {
10265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10266 }
10267 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10268 {
10269 arg2 = wxString_in_helper(obj1);
10270 if (arg2 == NULL) SWIG_fail;
10271 temp2 = true;
10272 }
10273 {
10274 PyThreadState* __tstate = wxPyBeginAllowThreads();
10275 result = (arg1)->GetProtocol((wxString const &)*arg2);
10276 wxPyEndAllowThreads(__tstate);
10277 if (PyErr_Occurred()) SWIG_fail;
10278 }
10279 {
10280 #if wxUSE_UNICODE
10281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10282 #else
10283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10284 #endif
10285 }
10286 {
10287 if (temp2)
10288 delete arg2;
10289 }
10290 return resultobj;
10291 fail:
10292 {
10293 if (temp2)
10294 delete arg2;
10295 }
10296 return NULL;
10297 }
10298
10299
10300 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10301 PyObject *resultobj = 0;
10302 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10303 wxString *arg2 = 0 ;
10304 wxString result;
10305 void *argp1 = 0 ;
10306 int res1 = 0 ;
10307 bool temp2 = false ;
10308 PyObject * obj0 = 0 ;
10309 PyObject * obj1 = 0 ;
10310 char * kwnames[] = {
10311 (char *) "self",(char *) "location", NULL
10312 };
10313
10314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10316 if (!SWIG_IsOK(res1)) {
10317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10318 }
10319 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10320 {
10321 arg2 = wxString_in_helper(obj1);
10322 if (arg2 == NULL) SWIG_fail;
10323 temp2 = true;
10324 }
10325 {
10326 PyThreadState* __tstate = wxPyBeginAllowThreads();
10327 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10328 wxPyEndAllowThreads(__tstate);
10329 if (PyErr_Occurred()) SWIG_fail;
10330 }
10331 {
10332 #if wxUSE_UNICODE
10333 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10334 #else
10335 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10336 #endif
10337 }
10338 {
10339 if (temp2)
10340 delete arg2;
10341 }
10342 return resultobj;
10343 fail:
10344 {
10345 if (temp2)
10346 delete arg2;
10347 }
10348 return NULL;
10349 }
10350
10351
10352 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10353 PyObject *resultobj = 0;
10354 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10355 wxString *arg2 = 0 ;
10356 wxString result;
10357 void *argp1 = 0 ;
10358 int res1 = 0 ;
10359 bool temp2 = false ;
10360 PyObject * obj0 = 0 ;
10361 PyObject * obj1 = 0 ;
10362 char * kwnames[] = {
10363 (char *) "self",(char *) "location", NULL
10364 };
10365
10366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10368 if (!SWIG_IsOK(res1)) {
10369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10370 }
10371 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10372 {
10373 arg2 = wxString_in_helper(obj1);
10374 if (arg2 == NULL) SWIG_fail;
10375 temp2 = true;
10376 }
10377 {
10378 PyThreadState* __tstate = wxPyBeginAllowThreads();
10379 result = (arg1)->GetAnchor((wxString const &)*arg2);
10380 wxPyEndAllowThreads(__tstate);
10381 if (PyErr_Occurred()) SWIG_fail;
10382 }
10383 {
10384 #if wxUSE_UNICODE
10385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10386 #else
10387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10388 #endif
10389 }
10390 {
10391 if (temp2)
10392 delete arg2;
10393 }
10394 return resultobj;
10395 fail:
10396 {
10397 if (temp2)
10398 delete arg2;
10399 }
10400 return NULL;
10401 }
10402
10403
10404 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10405 PyObject *resultobj = 0;
10406 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10407 wxString *arg2 = 0 ;
10408 wxString result;
10409 void *argp1 = 0 ;
10410 int res1 = 0 ;
10411 bool temp2 = false ;
10412 PyObject * obj0 = 0 ;
10413 PyObject * obj1 = 0 ;
10414 char * kwnames[] = {
10415 (char *) "self",(char *) "location", NULL
10416 };
10417
10418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10420 if (!SWIG_IsOK(res1)) {
10421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10422 }
10423 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10424 {
10425 arg2 = wxString_in_helper(obj1);
10426 if (arg2 == NULL) SWIG_fail;
10427 temp2 = true;
10428 }
10429 {
10430 PyThreadState* __tstate = wxPyBeginAllowThreads();
10431 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10432 wxPyEndAllowThreads(__tstate);
10433 if (PyErr_Occurred()) SWIG_fail;
10434 }
10435 {
10436 #if wxUSE_UNICODE
10437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10438 #else
10439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10440 #endif
10441 }
10442 {
10443 if (temp2)
10444 delete arg2;
10445 }
10446 return resultobj;
10447 fail:
10448 {
10449 if (temp2)
10450 delete arg2;
10451 }
10452 return NULL;
10453 }
10454
10455
10456 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10457 PyObject *resultobj = 0;
10458 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10459 wxString *arg2 = 0 ;
10460 wxString result;
10461 void *argp1 = 0 ;
10462 int res1 = 0 ;
10463 bool temp2 = false ;
10464 PyObject * obj0 = 0 ;
10465 PyObject * obj1 = 0 ;
10466 char * kwnames[] = {
10467 (char *) "self",(char *) "location", NULL
10468 };
10469
10470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10472 if (!SWIG_IsOK(res1)) {
10473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10474 }
10475 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10476 {
10477 arg2 = wxString_in_helper(obj1);
10478 if (arg2 == NULL) SWIG_fail;
10479 temp2 = true;
10480 }
10481 {
10482 PyThreadState* __tstate = wxPyBeginAllowThreads();
10483 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10484 wxPyEndAllowThreads(__tstate);
10485 if (PyErr_Occurred()) SWIG_fail;
10486 }
10487 {
10488 #if wxUSE_UNICODE
10489 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10490 #else
10491 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10492 #endif
10493 }
10494 {
10495 if (temp2)
10496 delete arg2;
10497 }
10498 return resultobj;
10499 fail:
10500 {
10501 if (temp2)
10502 delete arg2;
10503 }
10504 return NULL;
10505 }
10506
10507
10508 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10509 PyObject *obj;
10510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10511 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10512 return SWIG_Py_Void();
10513 }
10514
10515 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10516 return SWIG_Python_InitShadowInstance(args);
10517 }
10518
10519 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10520 PyObject *resultobj = 0;
10521 wxFileSystem *result = 0 ;
10522
10523 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10524 {
10525 PyThreadState* __tstate = wxPyBeginAllowThreads();
10526 result = (wxFileSystem *)new wxFileSystem();
10527 wxPyEndAllowThreads(__tstate);
10528 if (PyErr_Occurred()) SWIG_fail;
10529 }
10530 {
10531 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10532 }
10533 return resultobj;
10534 fail:
10535 return NULL;
10536 }
10537
10538
10539 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10540 PyObject *resultobj = 0;
10541 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10542 void *argp1 = 0 ;
10543 int res1 = 0 ;
10544 PyObject *swig_obj[1] ;
10545
10546 if (!args) SWIG_fail;
10547 swig_obj[0] = args;
10548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10549 if (!SWIG_IsOK(res1)) {
10550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10551 }
10552 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10553 {
10554 PyThreadState* __tstate = wxPyBeginAllowThreads();
10555 delete arg1;
10556
10557 wxPyEndAllowThreads(__tstate);
10558 if (PyErr_Occurred()) SWIG_fail;
10559 }
10560 resultobj = SWIG_Py_Void();
10561 return resultobj;
10562 fail:
10563 return NULL;
10564 }
10565
10566
10567 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10568 PyObject *resultobj = 0;
10569 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10570 wxString *arg2 = 0 ;
10571 bool arg3 = (bool) false ;
10572 void *argp1 = 0 ;
10573 int res1 = 0 ;
10574 bool temp2 = false ;
10575 bool val3 ;
10576 int ecode3 = 0 ;
10577 PyObject * obj0 = 0 ;
10578 PyObject * obj1 = 0 ;
10579 PyObject * obj2 = 0 ;
10580 char * kwnames[] = {
10581 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10582 };
10583
10584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10586 if (!SWIG_IsOK(res1)) {
10587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10588 }
10589 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10590 {
10591 arg2 = wxString_in_helper(obj1);
10592 if (arg2 == NULL) SWIG_fail;
10593 temp2 = true;
10594 }
10595 if (obj2) {
10596 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10597 if (!SWIG_IsOK(ecode3)) {
10598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10599 }
10600 arg3 = static_cast< bool >(val3);
10601 }
10602 {
10603 PyThreadState* __tstate = wxPyBeginAllowThreads();
10604 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10605 wxPyEndAllowThreads(__tstate);
10606 if (PyErr_Occurred()) SWIG_fail;
10607 }
10608 resultobj = SWIG_Py_Void();
10609 {
10610 if (temp2)
10611 delete arg2;
10612 }
10613 return resultobj;
10614 fail:
10615 {
10616 if (temp2)
10617 delete arg2;
10618 }
10619 return NULL;
10620 }
10621
10622
10623 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10624 PyObject *resultobj = 0;
10625 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10626 wxString result;
10627 void *argp1 = 0 ;
10628 int res1 = 0 ;
10629 PyObject *swig_obj[1] ;
10630
10631 if (!args) SWIG_fail;
10632 swig_obj[0] = args;
10633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10634 if (!SWIG_IsOK(res1)) {
10635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10636 }
10637 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10638 {
10639 PyThreadState* __tstate = wxPyBeginAllowThreads();
10640 result = (arg1)->GetPath();
10641 wxPyEndAllowThreads(__tstate);
10642 if (PyErr_Occurred()) SWIG_fail;
10643 }
10644 {
10645 #if wxUSE_UNICODE
10646 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10647 #else
10648 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10649 #endif
10650 }
10651 return resultobj;
10652 fail:
10653 return NULL;
10654 }
10655
10656
10657 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10658 PyObject *resultobj = 0;
10659 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10660 wxString *arg2 = 0 ;
10661 wxFSFile *result = 0 ;
10662 void *argp1 = 0 ;
10663 int res1 = 0 ;
10664 bool temp2 = false ;
10665 PyObject * obj0 = 0 ;
10666 PyObject * obj1 = 0 ;
10667 char * kwnames[] = {
10668 (char *) "self",(char *) "location", NULL
10669 };
10670
10671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10673 if (!SWIG_IsOK(res1)) {
10674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10675 }
10676 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10677 {
10678 arg2 = wxString_in_helper(obj1);
10679 if (arg2 == NULL) SWIG_fail;
10680 temp2 = true;
10681 }
10682 {
10683 PyThreadState* __tstate = wxPyBeginAllowThreads();
10684 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10685 wxPyEndAllowThreads(__tstate);
10686 if (PyErr_Occurred()) SWIG_fail;
10687 }
10688 {
10689 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10690 }
10691 {
10692 if (temp2)
10693 delete arg2;
10694 }
10695 return resultobj;
10696 fail:
10697 {
10698 if (temp2)
10699 delete arg2;
10700 }
10701 return NULL;
10702 }
10703
10704
10705 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10706 PyObject *resultobj = 0;
10707 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10708 wxString *arg2 = 0 ;
10709 int arg3 = (int) 0 ;
10710 wxString result;
10711 void *argp1 = 0 ;
10712 int res1 = 0 ;
10713 bool temp2 = false ;
10714 int val3 ;
10715 int ecode3 = 0 ;
10716 PyObject * obj0 = 0 ;
10717 PyObject * obj1 = 0 ;
10718 PyObject * obj2 = 0 ;
10719 char * kwnames[] = {
10720 (char *) "self",(char *) "spec",(char *) "flags", NULL
10721 };
10722
10723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10725 if (!SWIG_IsOK(res1)) {
10726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10727 }
10728 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10729 {
10730 arg2 = wxString_in_helper(obj1);
10731 if (arg2 == NULL) SWIG_fail;
10732 temp2 = true;
10733 }
10734 if (obj2) {
10735 ecode3 = SWIG_AsVal_int(obj2, &val3);
10736 if (!SWIG_IsOK(ecode3)) {
10737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10738 }
10739 arg3 = static_cast< int >(val3);
10740 }
10741 {
10742 PyThreadState* __tstate = wxPyBeginAllowThreads();
10743 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10744 wxPyEndAllowThreads(__tstate);
10745 if (PyErr_Occurred()) SWIG_fail;
10746 }
10747 {
10748 #if wxUSE_UNICODE
10749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10750 #else
10751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10752 #endif
10753 }
10754 {
10755 if (temp2)
10756 delete arg2;
10757 }
10758 return resultobj;
10759 fail:
10760 {
10761 if (temp2)
10762 delete arg2;
10763 }
10764 return NULL;
10765 }
10766
10767
10768 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10769 PyObject *resultobj = 0;
10770 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10771 wxString result;
10772 void *argp1 = 0 ;
10773 int res1 = 0 ;
10774 PyObject *swig_obj[1] ;
10775
10776 if (!args) SWIG_fail;
10777 swig_obj[0] = args;
10778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10779 if (!SWIG_IsOK(res1)) {
10780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10781 }
10782 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10783 {
10784 PyThreadState* __tstate = wxPyBeginAllowThreads();
10785 result = (arg1)->FindNext();
10786 wxPyEndAllowThreads(__tstate);
10787 if (PyErr_Occurred()) SWIG_fail;
10788 }
10789 {
10790 #if wxUSE_UNICODE
10791 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10792 #else
10793 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10794 #endif
10795 }
10796 return resultobj;
10797 fail:
10798 return NULL;
10799 }
10800
10801
10802 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10803 PyObject *resultobj = 0;
10804 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10805 int res1 = 0 ;
10806 PyObject * obj0 = 0 ;
10807 char * kwnames[] = {
10808 (char *) "handler", NULL
10809 };
10810
10811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10812 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10813 if (!SWIG_IsOK(res1)) {
10814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10815 }
10816 {
10817 PyThreadState* __tstate = wxPyBeginAllowThreads();
10818 wxFileSystem::AddHandler(arg1);
10819 wxPyEndAllowThreads(__tstate);
10820 if (PyErr_Occurred()) SWIG_fail;
10821 }
10822 resultobj = SWIG_Py_Void();
10823 return resultobj;
10824 fail:
10825 return NULL;
10826 }
10827
10828
10829 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10830 PyObject *resultobj = 0;
10831
10832 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10833 {
10834 PyThreadState* __tstate = wxPyBeginAllowThreads();
10835 wxFileSystem::CleanUpHandlers();
10836 wxPyEndAllowThreads(__tstate);
10837 if (PyErr_Occurred()) SWIG_fail;
10838 }
10839 resultobj = SWIG_Py_Void();
10840 return resultobj;
10841 fail:
10842 return NULL;
10843 }
10844
10845
10846 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10847 PyObject *resultobj = 0;
10848 wxString *arg1 = 0 ;
10849 wxString result;
10850 bool temp1 = false ;
10851 PyObject * obj0 = 0 ;
10852 char * kwnames[] = {
10853 (char *) "filename", NULL
10854 };
10855
10856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10857 {
10858 arg1 = wxString_in_helper(obj0);
10859 if (arg1 == NULL) SWIG_fail;
10860 temp1 = true;
10861 }
10862 {
10863 PyThreadState* __tstate = wxPyBeginAllowThreads();
10864 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10865 wxPyEndAllowThreads(__tstate);
10866 if (PyErr_Occurred()) SWIG_fail;
10867 }
10868 {
10869 #if wxUSE_UNICODE
10870 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10871 #else
10872 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10873 #endif
10874 }
10875 {
10876 if (temp1)
10877 delete arg1;
10878 }
10879 return resultobj;
10880 fail:
10881 {
10882 if (temp1)
10883 delete arg1;
10884 }
10885 return NULL;
10886 }
10887
10888
10889 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10890 PyObject *resultobj = 0;
10891 wxString *arg1 = 0 ;
10892 wxString result;
10893 bool temp1 = false ;
10894 PyObject * obj0 = 0 ;
10895 char * kwnames[] = {
10896 (char *) "url", NULL
10897 };
10898
10899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10900 {
10901 arg1 = wxString_in_helper(obj0);
10902 if (arg1 == NULL) SWIG_fail;
10903 temp1 = true;
10904 }
10905 {
10906 PyThreadState* __tstate = wxPyBeginAllowThreads();
10907 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10908 wxPyEndAllowThreads(__tstate);
10909 if (PyErr_Occurred()) SWIG_fail;
10910 }
10911 {
10912 #if wxUSE_UNICODE
10913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10914 #else
10915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10916 #endif
10917 }
10918 {
10919 if (temp1)
10920 delete arg1;
10921 }
10922 return resultobj;
10923 fail:
10924 {
10925 if (temp1)
10926 delete arg1;
10927 }
10928 return NULL;
10929 }
10930
10931
10932 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10933 PyObject *obj;
10934 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10935 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10936 return SWIG_Py_Void();
10937 }
10938
10939 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10940 return SWIG_Python_InitShadowInstance(args);
10941 }
10942
10943 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10944 PyObject *resultobj = 0;
10945 wxInternetFSHandler *result = 0 ;
10946
10947 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10948 {
10949 PyThreadState* __tstate = wxPyBeginAllowThreads();
10950 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10951 wxPyEndAllowThreads(__tstate);
10952 if (PyErr_Occurred()) SWIG_fail;
10953 }
10954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10955 return resultobj;
10956 fail:
10957 return NULL;
10958 }
10959
10960
10961 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10962 PyObject *resultobj = 0;
10963 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10964 wxString *arg2 = 0 ;
10965 bool result;
10966 void *argp1 = 0 ;
10967 int res1 = 0 ;
10968 bool temp2 = false ;
10969 PyObject * obj0 = 0 ;
10970 PyObject * obj1 = 0 ;
10971 char * kwnames[] = {
10972 (char *) "self",(char *) "location", NULL
10973 };
10974
10975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10977 if (!SWIG_IsOK(res1)) {
10978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10979 }
10980 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10981 {
10982 arg2 = wxString_in_helper(obj1);
10983 if (arg2 == NULL) SWIG_fail;
10984 temp2 = true;
10985 }
10986 {
10987 PyThreadState* __tstate = wxPyBeginAllowThreads();
10988 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10989 wxPyEndAllowThreads(__tstate);
10990 if (PyErr_Occurred()) SWIG_fail;
10991 }
10992 {
10993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10994 }
10995 {
10996 if (temp2)
10997 delete arg2;
10998 }
10999 return resultobj;
11000 fail:
11001 {
11002 if (temp2)
11003 delete arg2;
11004 }
11005 return NULL;
11006 }
11007
11008
11009 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11010 PyObject *resultobj = 0;
11011 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11012 wxFileSystem *arg2 = 0 ;
11013 wxString *arg3 = 0 ;
11014 wxFSFile *result = 0 ;
11015 void *argp1 = 0 ;
11016 int res1 = 0 ;
11017 void *argp2 = 0 ;
11018 int res2 = 0 ;
11019 bool temp3 = false ;
11020 PyObject * obj0 = 0 ;
11021 PyObject * obj1 = 0 ;
11022 PyObject * obj2 = 0 ;
11023 char * kwnames[] = {
11024 (char *) "self",(char *) "fs",(char *) "location", NULL
11025 };
11026
11027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11029 if (!SWIG_IsOK(res1)) {
11030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11031 }
11032 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11033 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11034 if (!SWIG_IsOK(res2)) {
11035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11036 }
11037 if (!argp2) {
11038 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11039 }
11040 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11041 {
11042 arg3 = wxString_in_helper(obj2);
11043 if (arg3 == NULL) SWIG_fail;
11044 temp3 = true;
11045 }
11046 {
11047 PyThreadState* __tstate = wxPyBeginAllowThreads();
11048 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11049 wxPyEndAllowThreads(__tstate);
11050 if (PyErr_Occurred()) SWIG_fail;
11051 }
11052 {
11053 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11054 }
11055 {
11056 if (temp3)
11057 delete arg3;
11058 }
11059 return resultobj;
11060 fail:
11061 {
11062 if (temp3)
11063 delete arg3;
11064 }
11065 return NULL;
11066 }
11067
11068
11069 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11070 PyObject *obj;
11071 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11072 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11073 return SWIG_Py_Void();
11074 }
11075
11076 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11077 return SWIG_Python_InitShadowInstance(args);
11078 }
11079
11080 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11081 PyObject *resultobj = 0;
11082 wxZipFSHandler *result = 0 ;
11083
11084 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11085 {
11086 PyThreadState* __tstate = wxPyBeginAllowThreads();
11087 result = (wxZipFSHandler *)new wxZipFSHandler();
11088 wxPyEndAllowThreads(__tstate);
11089 if (PyErr_Occurred()) SWIG_fail;
11090 }
11091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11092 return resultobj;
11093 fail:
11094 return NULL;
11095 }
11096
11097
11098 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11099 PyObject *resultobj = 0;
11100 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11101 wxString *arg2 = 0 ;
11102 bool result;
11103 void *argp1 = 0 ;
11104 int res1 = 0 ;
11105 bool temp2 = false ;
11106 PyObject * obj0 = 0 ;
11107 PyObject * obj1 = 0 ;
11108 char * kwnames[] = {
11109 (char *) "self",(char *) "location", NULL
11110 };
11111
11112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11114 if (!SWIG_IsOK(res1)) {
11115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11116 }
11117 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11118 {
11119 arg2 = wxString_in_helper(obj1);
11120 if (arg2 == NULL) SWIG_fail;
11121 temp2 = true;
11122 }
11123 {
11124 PyThreadState* __tstate = wxPyBeginAllowThreads();
11125 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11126 wxPyEndAllowThreads(__tstate);
11127 if (PyErr_Occurred()) SWIG_fail;
11128 }
11129 {
11130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11131 }
11132 {
11133 if (temp2)
11134 delete arg2;
11135 }
11136 return resultobj;
11137 fail:
11138 {
11139 if (temp2)
11140 delete arg2;
11141 }
11142 return NULL;
11143 }
11144
11145
11146 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11147 PyObject *resultobj = 0;
11148 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11149 wxFileSystem *arg2 = 0 ;
11150 wxString *arg3 = 0 ;
11151 wxFSFile *result = 0 ;
11152 void *argp1 = 0 ;
11153 int res1 = 0 ;
11154 void *argp2 = 0 ;
11155 int res2 = 0 ;
11156 bool temp3 = false ;
11157 PyObject * obj0 = 0 ;
11158 PyObject * obj1 = 0 ;
11159 PyObject * obj2 = 0 ;
11160 char * kwnames[] = {
11161 (char *) "self",(char *) "fs",(char *) "location", NULL
11162 };
11163
11164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11166 if (!SWIG_IsOK(res1)) {
11167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11168 }
11169 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11170 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11171 if (!SWIG_IsOK(res2)) {
11172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11173 }
11174 if (!argp2) {
11175 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11176 }
11177 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11178 {
11179 arg3 = wxString_in_helper(obj2);
11180 if (arg3 == NULL) SWIG_fail;
11181 temp3 = true;
11182 }
11183 {
11184 PyThreadState* __tstate = wxPyBeginAllowThreads();
11185 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11186 wxPyEndAllowThreads(__tstate);
11187 if (PyErr_Occurred()) SWIG_fail;
11188 }
11189 {
11190 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11191 }
11192 {
11193 if (temp3)
11194 delete arg3;
11195 }
11196 return resultobj;
11197 fail:
11198 {
11199 if (temp3)
11200 delete arg3;
11201 }
11202 return NULL;
11203 }
11204
11205
11206 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11207 PyObject *resultobj = 0;
11208 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11209 wxString *arg2 = 0 ;
11210 int arg3 = (int) 0 ;
11211 wxString result;
11212 void *argp1 = 0 ;
11213 int res1 = 0 ;
11214 bool temp2 = false ;
11215 int val3 ;
11216 int ecode3 = 0 ;
11217 PyObject * obj0 = 0 ;
11218 PyObject * obj1 = 0 ;
11219 PyObject * obj2 = 0 ;
11220 char * kwnames[] = {
11221 (char *) "self",(char *) "spec",(char *) "flags", NULL
11222 };
11223
11224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11226 if (!SWIG_IsOK(res1)) {
11227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11228 }
11229 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11230 {
11231 arg2 = wxString_in_helper(obj1);
11232 if (arg2 == NULL) SWIG_fail;
11233 temp2 = true;
11234 }
11235 if (obj2) {
11236 ecode3 = SWIG_AsVal_int(obj2, &val3);
11237 if (!SWIG_IsOK(ecode3)) {
11238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11239 }
11240 arg3 = static_cast< int >(val3);
11241 }
11242 {
11243 PyThreadState* __tstate = wxPyBeginAllowThreads();
11244 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11245 wxPyEndAllowThreads(__tstate);
11246 if (PyErr_Occurred()) SWIG_fail;
11247 }
11248 {
11249 #if wxUSE_UNICODE
11250 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11251 #else
11252 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11253 #endif
11254 }
11255 {
11256 if (temp2)
11257 delete arg2;
11258 }
11259 return resultobj;
11260 fail:
11261 {
11262 if (temp2)
11263 delete arg2;
11264 }
11265 return NULL;
11266 }
11267
11268
11269 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11270 PyObject *resultobj = 0;
11271 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11272 wxString result;
11273 void *argp1 = 0 ;
11274 int res1 = 0 ;
11275 PyObject *swig_obj[1] ;
11276
11277 if (!args) SWIG_fail;
11278 swig_obj[0] = args;
11279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11280 if (!SWIG_IsOK(res1)) {
11281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11282 }
11283 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11284 {
11285 PyThreadState* __tstate = wxPyBeginAllowThreads();
11286 result = (arg1)->FindNext();
11287 wxPyEndAllowThreads(__tstate);
11288 if (PyErr_Occurred()) SWIG_fail;
11289 }
11290 {
11291 #if wxUSE_UNICODE
11292 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11293 #else
11294 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11295 #endif
11296 }
11297 return resultobj;
11298 fail:
11299 return NULL;
11300 }
11301
11302
11303 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11304 PyObject *obj;
11305 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11306 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11307 return SWIG_Py_Void();
11308 }
11309
11310 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11311 return SWIG_Python_InitShadowInstance(args);
11312 }
11313
11314 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11315 PyObject *resultobj = 0;
11316 wxString *arg1 = 0 ;
11317 wxImage *arg2 = 0 ;
11318 long arg3 ;
11319 bool temp1 = false ;
11320 void *argp2 = 0 ;
11321 int res2 = 0 ;
11322 long val3 ;
11323 int ecode3 = 0 ;
11324 PyObject * obj0 = 0 ;
11325 PyObject * obj1 = 0 ;
11326 PyObject * obj2 = 0 ;
11327 char * kwnames[] = {
11328 (char *) "filename",(char *) "image",(char *) "type", NULL
11329 };
11330
11331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11332 {
11333 arg1 = wxString_in_helper(obj0);
11334 if (arg1 == NULL) SWIG_fail;
11335 temp1 = true;
11336 }
11337 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11338 if (!SWIG_IsOK(res2)) {
11339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11340 }
11341 if (!argp2) {
11342 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11343 }
11344 arg2 = reinterpret_cast< wxImage * >(argp2);
11345 ecode3 = SWIG_AsVal_long(obj2, &val3);
11346 if (!SWIG_IsOK(ecode3)) {
11347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11348 }
11349 arg3 = static_cast< long >(val3);
11350 {
11351 PyThreadState* __tstate = wxPyBeginAllowThreads();
11352 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11353 wxPyEndAllowThreads(__tstate);
11354 if (PyErr_Occurred()) SWIG_fail;
11355 }
11356 resultobj = SWIG_Py_Void();
11357 {
11358 if (temp1)
11359 delete arg1;
11360 }
11361 return resultobj;
11362 fail:
11363 {
11364 if (temp1)
11365 delete arg1;
11366 }
11367 return NULL;
11368 }
11369
11370
11371 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11372 PyObject *resultobj = 0;
11373 wxString *arg1 = 0 ;
11374 wxBitmap *arg2 = 0 ;
11375 long arg3 ;
11376 bool temp1 = false ;
11377 void *argp2 = 0 ;
11378 int res2 = 0 ;
11379 long val3 ;
11380 int ecode3 = 0 ;
11381 PyObject * obj0 = 0 ;
11382 PyObject * obj1 = 0 ;
11383 PyObject * obj2 = 0 ;
11384 char * kwnames[] = {
11385 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11386 };
11387
11388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11389 {
11390 arg1 = wxString_in_helper(obj0);
11391 if (arg1 == NULL) SWIG_fail;
11392 temp1 = true;
11393 }
11394 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11395 if (!SWIG_IsOK(res2)) {
11396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11397 }
11398 if (!argp2) {
11399 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11400 }
11401 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11402 ecode3 = SWIG_AsVal_long(obj2, &val3);
11403 if (!SWIG_IsOK(ecode3)) {
11404 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11405 }
11406 arg3 = static_cast< long >(val3);
11407 {
11408 PyThreadState* __tstate = wxPyBeginAllowThreads();
11409 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11410 wxPyEndAllowThreads(__tstate);
11411 if (PyErr_Occurred()) SWIG_fail;
11412 }
11413 resultobj = SWIG_Py_Void();
11414 {
11415 if (temp1)
11416 delete arg1;
11417 }
11418 return resultobj;
11419 fail:
11420 {
11421 if (temp1)
11422 delete arg1;
11423 }
11424 return NULL;
11425 }
11426
11427
11428 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11429 PyObject *resultobj = 0;
11430 wxString *arg1 = 0 ;
11431 PyObject *arg2 = (PyObject *) 0 ;
11432 bool temp1 = false ;
11433 PyObject * obj0 = 0 ;
11434 PyObject * obj1 = 0 ;
11435 char * kwnames[] = {
11436 (char *) "filename",(char *) "data", NULL
11437 };
11438
11439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11440 {
11441 arg1 = wxString_in_helper(obj0);
11442 if (arg1 == NULL) SWIG_fail;
11443 temp1 = true;
11444 }
11445 arg2 = obj1;
11446 {
11447 PyThreadState* __tstate = wxPyBeginAllowThreads();
11448 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11449 wxPyEndAllowThreads(__tstate);
11450 if (PyErr_Occurred()) SWIG_fail;
11451 }
11452 resultobj = SWIG_Py_Void();
11453 {
11454 if (temp1)
11455 delete arg1;
11456 }
11457 return resultobj;
11458 fail:
11459 {
11460 if (temp1)
11461 delete arg1;
11462 }
11463 return NULL;
11464 }
11465
11466
11467 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11468 PyObject *resultobj = 0;
11469 wxMemoryFSHandler *result = 0 ;
11470
11471 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11472 {
11473 PyThreadState* __tstate = wxPyBeginAllowThreads();
11474 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11475 wxPyEndAllowThreads(__tstate);
11476 if (PyErr_Occurred()) SWIG_fail;
11477 }
11478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11479 return resultobj;
11480 fail:
11481 return NULL;
11482 }
11483
11484
11485 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11486 PyObject *resultobj = 0;
11487 wxString *arg1 = 0 ;
11488 bool temp1 = false ;
11489 PyObject * obj0 = 0 ;
11490 char * kwnames[] = {
11491 (char *) "filename", NULL
11492 };
11493
11494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11495 {
11496 arg1 = wxString_in_helper(obj0);
11497 if (arg1 == NULL) SWIG_fail;
11498 temp1 = true;
11499 }
11500 {
11501 PyThreadState* __tstate = wxPyBeginAllowThreads();
11502 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11503 wxPyEndAllowThreads(__tstate);
11504 if (PyErr_Occurred()) SWIG_fail;
11505 }
11506 resultobj = SWIG_Py_Void();
11507 {
11508 if (temp1)
11509 delete arg1;
11510 }
11511 return resultobj;
11512 fail:
11513 {
11514 if (temp1)
11515 delete arg1;
11516 }
11517 return NULL;
11518 }
11519
11520
11521 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11522 PyObject *resultobj = 0;
11523 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11524 wxString *arg2 = 0 ;
11525 bool result;
11526 void *argp1 = 0 ;
11527 int res1 = 0 ;
11528 bool temp2 = false ;
11529 PyObject * obj0 = 0 ;
11530 PyObject * obj1 = 0 ;
11531 char * kwnames[] = {
11532 (char *) "self",(char *) "location", NULL
11533 };
11534
11535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11537 if (!SWIG_IsOK(res1)) {
11538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11539 }
11540 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11541 {
11542 arg2 = wxString_in_helper(obj1);
11543 if (arg2 == NULL) SWIG_fail;
11544 temp2 = true;
11545 }
11546 {
11547 PyThreadState* __tstate = wxPyBeginAllowThreads();
11548 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11549 wxPyEndAllowThreads(__tstate);
11550 if (PyErr_Occurred()) SWIG_fail;
11551 }
11552 {
11553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11554 }
11555 {
11556 if (temp2)
11557 delete arg2;
11558 }
11559 return resultobj;
11560 fail:
11561 {
11562 if (temp2)
11563 delete arg2;
11564 }
11565 return NULL;
11566 }
11567
11568
11569 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11570 PyObject *resultobj = 0;
11571 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11572 wxFileSystem *arg2 = 0 ;
11573 wxString *arg3 = 0 ;
11574 wxFSFile *result = 0 ;
11575 void *argp1 = 0 ;
11576 int res1 = 0 ;
11577 void *argp2 = 0 ;
11578 int res2 = 0 ;
11579 bool temp3 = false ;
11580 PyObject * obj0 = 0 ;
11581 PyObject * obj1 = 0 ;
11582 PyObject * obj2 = 0 ;
11583 char * kwnames[] = {
11584 (char *) "self",(char *) "fs",(char *) "location", NULL
11585 };
11586
11587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11589 if (!SWIG_IsOK(res1)) {
11590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11591 }
11592 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11593 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11594 if (!SWIG_IsOK(res2)) {
11595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11596 }
11597 if (!argp2) {
11598 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11599 }
11600 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11601 {
11602 arg3 = wxString_in_helper(obj2);
11603 if (arg3 == NULL) SWIG_fail;
11604 temp3 = true;
11605 }
11606 {
11607 PyThreadState* __tstate = wxPyBeginAllowThreads();
11608 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11609 wxPyEndAllowThreads(__tstate);
11610 if (PyErr_Occurred()) SWIG_fail;
11611 }
11612 {
11613 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11614 }
11615 {
11616 if (temp3)
11617 delete arg3;
11618 }
11619 return resultobj;
11620 fail:
11621 {
11622 if (temp3)
11623 delete arg3;
11624 }
11625 return NULL;
11626 }
11627
11628
11629 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11630 PyObject *resultobj = 0;
11631 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11632 wxString *arg2 = 0 ;
11633 int arg3 = (int) 0 ;
11634 wxString result;
11635 void *argp1 = 0 ;
11636 int res1 = 0 ;
11637 bool temp2 = false ;
11638 int val3 ;
11639 int ecode3 = 0 ;
11640 PyObject * obj0 = 0 ;
11641 PyObject * obj1 = 0 ;
11642 PyObject * obj2 = 0 ;
11643 char * kwnames[] = {
11644 (char *) "self",(char *) "spec",(char *) "flags", NULL
11645 };
11646
11647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11651 }
11652 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11653 {
11654 arg2 = wxString_in_helper(obj1);
11655 if (arg2 == NULL) SWIG_fail;
11656 temp2 = true;
11657 }
11658 if (obj2) {
11659 ecode3 = SWIG_AsVal_int(obj2, &val3);
11660 if (!SWIG_IsOK(ecode3)) {
11661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11662 }
11663 arg3 = static_cast< int >(val3);
11664 }
11665 {
11666 PyThreadState* __tstate = wxPyBeginAllowThreads();
11667 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 {
11672 #if wxUSE_UNICODE
11673 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11674 #else
11675 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11676 #endif
11677 }
11678 {
11679 if (temp2)
11680 delete arg2;
11681 }
11682 return resultobj;
11683 fail:
11684 {
11685 if (temp2)
11686 delete arg2;
11687 }
11688 return NULL;
11689 }
11690
11691
11692 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11693 PyObject *resultobj = 0;
11694 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11695 wxString result;
11696 void *argp1 = 0 ;
11697 int res1 = 0 ;
11698 PyObject *swig_obj[1] ;
11699
11700 if (!args) SWIG_fail;
11701 swig_obj[0] = args;
11702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11703 if (!SWIG_IsOK(res1)) {
11704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11705 }
11706 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11707 {
11708 PyThreadState* __tstate = wxPyBeginAllowThreads();
11709 result = (arg1)->FindNext();
11710 wxPyEndAllowThreads(__tstate);
11711 if (PyErr_Occurred()) SWIG_fail;
11712 }
11713 {
11714 #if wxUSE_UNICODE
11715 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11716 #else
11717 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11718 #endif
11719 }
11720 return resultobj;
11721 fail:
11722 return NULL;
11723 }
11724
11725
11726 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11727 PyObject *obj;
11728 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11729 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11730 return SWIG_Py_Void();
11731 }
11732
11733 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11734 return SWIG_Python_InitShadowInstance(args);
11735 }
11736
11737 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11738 PyObject *resultobj = 0;
11739 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11740 wxString result;
11741 void *argp1 = 0 ;
11742 int res1 = 0 ;
11743 PyObject *swig_obj[1] ;
11744
11745 if (!args) SWIG_fail;
11746 swig_obj[0] = args;
11747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11748 if (!SWIG_IsOK(res1)) {
11749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11750 }
11751 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11752 {
11753 PyThreadState* __tstate = wxPyBeginAllowThreads();
11754 result = (arg1)->GetName();
11755 wxPyEndAllowThreads(__tstate);
11756 if (PyErr_Occurred()) SWIG_fail;
11757 }
11758 {
11759 #if wxUSE_UNICODE
11760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11761 #else
11762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11763 #endif
11764 }
11765 return resultobj;
11766 fail:
11767 return NULL;
11768 }
11769
11770
11771 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11772 PyObject *resultobj = 0;
11773 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11774 wxString result;
11775 void *argp1 = 0 ;
11776 int res1 = 0 ;
11777 PyObject *swig_obj[1] ;
11778
11779 if (!args) SWIG_fail;
11780 swig_obj[0] = args;
11781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11782 if (!SWIG_IsOK(res1)) {
11783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11784 }
11785 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11786 {
11787 PyThreadState* __tstate = wxPyBeginAllowThreads();
11788 result = (arg1)->GetExtension();
11789 wxPyEndAllowThreads(__tstate);
11790 if (PyErr_Occurred()) SWIG_fail;
11791 }
11792 {
11793 #if wxUSE_UNICODE
11794 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11795 #else
11796 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11797 #endif
11798 }
11799 return resultobj;
11800 fail:
11801 return NULL;
11802 }
11803
11804
11805 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11806 PyObject *resultobj = 0;
11807 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11808 long result;
11809 void *argp1 = 0 ;
11810 int res1 = 0 ;
11811 PyObject *swig_obj[1] ;
11812
11813 if (!args) SWIG_fail;
11814 swig_obj[0] = args;
11815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11816 if (!SWIG_IsOK(res1)) {
11817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11818 }
11819 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11820 {
11821 PyThreadState* __tstate = wxPyBeginAllowThreads();
11822 result = (long)(arg1)->GetType();
11823 wxPyEndAllowThreads(__tstate);
11824 if (PyErr_Occurred()) SWIG_fail;
11825 }
11826 resultobj = SWIG_From_long(static_cast< long >(result));
11827 return resultobj;
11828 fail:
11829 return NULL;
11830 }
11831
11832
11833 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11834 PyObject *resultobj = 0;
11835 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11836 wxString result;
11837 void *argp1 = 0 ;
11838 int res1 = 0 ;
11839 PyObject *swig_obj[1] ;
11840
11841 if (!args) SWIG_fail;
11842 swig_obj[0] = args;
11843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11844 if (!SWIG_IsOK(res1)) {
11845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11846 }
11847 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11848 {
11849 PyThreadState* __tstate = wxPyBeginAllowThreads();
11850 result = (arg1)->GetMimeType();
11851 wxPyEndAllowThreads(__tstate);
11852 if (PyErr_Occurred()) SWIG_fail;
11853 }
11854 {
11855 #if wxUSE_UNICODE
11856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11857 #else
11858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11859 #endif
11860 }
11861 return resultobj;
11862 fail:
11863 return NULL;
11864 }
11865
11866
11867 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11868 PyObject *resultobj = 0;
11869 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11870 wxString *arg2 = 0 ;
11871 bool result;
11872 void *argp1 = 0 ;
11873 int res1 = 0 ;
11874 bool temp2 = false ;
11875 PyObject * obj0 = 0 ;
11876 PyObject * obj1 = 0 ;
11877 char * kwnames[] = {
11878 (char *) "self",(char *) "name", NULL
11879 };
11880
11881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11883 if (!SWIG_IsOK(res1)) {
11884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11885 }
11886 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11887 {
11888 arg2 = wxString_in_helper(obj1);
11889 if (arg2 == NULL) SWIG_fail;
11890 temp2 = true;
11891 }
11892 {
11893 PyThreadState* __tstate = wxPyBeginAllowThreads();
11894 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11895 wxPyEndAllowThreads(__tstate);
11896 if (PyErr_Occurred()) SWIG_fail;
11897 }
11898 {
11899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11900 }
11901 {
11902 if (temp2)
11903 delete arg2;
11904 }
11905 return resultobj;
11906 fail:
11907 {
11908 if (temp2)
11909 delete arg2;
11910 }
11911 return NULL;
11912 }
11913
11914
11915 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11916 PyObject *resultobj = 0;
11917 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11918 wxInputStream *arg2 = 0 ;
11919 bool result;
11920 void *argp1 = 0 ;
11921 int res1 = 0 ;
11922 wxPyInputStream *temp2 ;
11923 bool created2 ;
11924 PyObject * obj0 = 0 ;
11925 PyObject * obj1 = 0 ;
11926 char * kwnames[] = {
11927 (char *) "self",(char *) "stream", NULL
11928 };
11929
11930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11932 if (!SWIG_IsOK(res1)) {
11933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11934 }
11935 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11936 {
11937 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11938 arg2 = temp2->m_wxis;
11939 created2 = false;
11940 } else {
11941 PyErr_Clear(); // clear the failure of the wxPyConvert above
11942 arg2 = wxPyCBInputStream_create(obj1, false);
11943 if (arg2 == NULL) {
11944 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11945 SWIG_fail;
11946 }
11947 created2 = true;
11948 }
11949 }
11950 {
11951 PyThreadState* __tstate = wxPyBeginAllowThreads();
11952 result = (bool)(arg1)->CanRead(*arg2);
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 {
11957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11958 }
11959 {
11960 if (created2) delete arg2;
11961 }
11962 return resultobj;
11963 fail:
11964 {
11965 if (created2) delete arg2;
11966 }
11967 return NULL;
11968 }
11969
11970
11971 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11972 PyObject *resultobj = 0;
11973 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11974 wxString *arg2 = 0 ;
11975 void *argp1 = 0 ;
11976 int res1 = 0 ;
11977 bool temp2 = false ;
11978 PyObject * obj0 = 0 ;
11979 PyObject * obj1 = 0 ;
11980 char * kwnames[] = {
11981 (char *) "self",(char *) "name", NULL
11982 };
11983
11984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11986 if (!SWIG_IsOK(res1)) {
11987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11988 }
11989 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11990 {
11991 arg2 = wxString_in_helper(obj1);
11992 if (arg2 == NULL) SWIG_fail;
11993 temp2 = true;
11994 }
11995 {
11996 PyThreadState* __tstate = wxPyBeginAllowThreads();
11997 (arg1)->SetName((wxString const &)*arg2);
11998 wxPyEndAllowThreads(__tstate);
11999 if (PyErr_Occurred()) SWIG_fail;
12000 }
12001 resultobj = SWIG_Py_Void();
12002 {
12003 if (temp2)
12004 delete arg2;
12005 }
12006 return resultobj;
12007 fail:
12008 {
12009 if (temp2)
12010 delete arg2;
12011 }
12012 return NULL;
12013 }
12014
12015
12016 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12017 PyObject *resultobj = 0;
12018 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12019 wxString *arg2 = 0 ;
12020 void *argp1 = 0 ;
12021 int res1 = 0 ;
12022 bool temp2 = false ;
12023 PyObject * obj0 = 0 ;
12024 PyObject * obj1 = 0 ;
12025 char * kwnames[] = {
12026 (char *) "self",(char *) "extension", NULL
12027 };
12028
12029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12031 if (!SWIG_IsOK(res1)) {
12032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12033 }
12034 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12035 {
12036 arg2 = wxString_in_helper(obj1);
12037 if (arg2 == NULL) SWIG_fail;
12038 temp2 = true;
12039 }
12040 {
12041 PyThreadState* __tstate = wxPyBeginAllowThreads();
12042 (arg1)->SetExtension((wxString const &)*arg2);
12043 wxPyEndAllowThreads(__tstate);
12044 if (PyErr_Occurred()) SWIG_fail;
12045 }
12046 resultobj = SWIG_Py_Void();
12047 {
12048 if (temp2)
12049 delete arg2;
12050 }
12051 return resultobj;
12052 fail:
12053 {
12054 if (temp2)
12055 delete arg2;
12056 }
12057 return NULL;
12058 }
12059
12060
12061 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12062 PyObject *resultobj = 0;
12063 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12064 long arg2 ;
12065 void *argp1 = 0 ;
12066 int res1 = 0 ;
12067 long val2 ;
12068 int ecode2 = 0 ;
12069 PyObject * obj0 = 0 ;
12070 PyObject * obj1 = 0 ;
12071 char * kwnames[] = {
12072 (char *) "self",(char *) "type", NULL
12073 };
12074
12075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12077 if (!SWIG_IsOK(res1)) {
12078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12079 }
12080 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12081 ecode2 = SWIG_AsVal_long(obj1, &val2);
12082 if (!SWIG_IsOK(ecode2)) {
12083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12084 }
12085 arg2 = static_cast< long >(val2);
12086 {
12087 PyThreadState* __tstate = wxPyBeginAllowThreads();
12088 (arg1)->SetType(arg2);
12089 wxPyEndAllowThreads(__tstate);
12090 if (PyErr_Occurred()) SWIG_fail;
12091 }
12092 resultobj = SWIG_Py_Void();
12093 return resultobj;
12094 fail:
12095 return NULL;
12096 }
12097
12098
12099 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12100 PyObject *resultobj = 0;
12101 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12102 wxString *arg2 = 0 ;
12103 void *argp1 = 0 ;
12104 int res1 = 0 ;
12105 bool temp2 = false ;
12106 PyObject * obj0 = 0 ;
12107 PyObject * obj1 = 0 ;
12108 char * kwnames[] = {
12109 (char *) "self",(char *) "mimetype", NULL
12110 };
12111
12112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12114 if (!SWIG_IsOK(res1)) {
12115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12116 }
12117 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12118 {
12119 arg2 = wxString_in_helper(obj1);
12120 if (arg2 == NULL) SWIG_fail;
12121 temp2 = true;
12122 }
12123 {
12124 PyThreadState* __tstate = wxPyBeginAllowThreads();
12125 (arg1)->SetMimeType((wxString const &)*arg2);
12126 wxPyEndAllowThreads(__tstate);
12127 if (PyErr_Occurred()) SWIG_fail;
12128 }
12129 resultobj = SWIG_Py_Void();
12130 {
12131 if (temp2)
12132 delete arg2;
12133 }
12134 return resultobj;
12135 fail:
12136 {
12137 if (temp2)
12138 delete arg2;
12139 }
12140 return NULL;
12141 }
12142
12143
12144 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12145 PyObject *obj;
12146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12147 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12148 return SWIG_Py_Void();
12149 }
12150
12151 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12152 PyObject *resultobj = 0;
12153 wxPyImageHandler *result = 0 ;
12154
12155 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12156 {
12157 PyThreadState* __tstate = wxPyBeginAllowThreads();
12158 result = (wxPyImageHandler *)new wxPyImageHandler();
12159 wxPyEndAllowThreads(__tstate);
12160 if (PyErr_Occurred()) SWIG_fail;
12161 }
12162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12163 return resultobj;
12164 fail:
12165 return NULL;
12166 }
12167
12168
12169 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12170 PyObject *resultobj = 0;
12171 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12172 PyObject *arg2 = (PyObject *) 0 ;
12173 void *argp1 = 0 ;
12174 int res1 = 0 ;
12175 PyObject * obj0 = 0 ;
12176 PyObject * obj1 = 0 ;
12177 char * kwnames[] = {
12178 (char *) "self",(char *) "self", NULL
12179 };
12180
12181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12183 if (!SWIG_IsOK(res1)) {
12184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12185 }
12186 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12187 arg2 = obj1;
12188 {
12189 PyThreadState* __tstate = wxPyBeginAllowThreads();
12190 (arg1)->_SetSelf(arg2);
12191 wxPyEndAllowThreads(__tstate);
12192 if (PyErr_Occurred()) SWIG_fail;
12193 }
12194 resultobj = SWIG_Py_Void();
12195 return resultobj;
12196 fail:
12197 return NULL;
12198 }
12199
12200
12201 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12202 PyObject *obj;
12203 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12204 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12205 return SWIG_Py_Void();
12206 }
12207
12208 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12209 return SWIG_Python_InitShadowInstance(args);
12210 }
12211
12212 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12213 PyObject *resultobj = 0;
12214 wxImageHistogram *result = 0 ;
12215
12216 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12217 {
12218 PyThreadState* __tstate = wxPyBeginAllowThreads();
12219 result = (wxImageHistogram *)new wxImageHistogram();
12220 wxPyEndAllowThreads(__tstate);
12221 if (PyErr_Occurred()) SWIG_fail;
12222 }
12223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12224 return resultobj;
12225 fail:
12226 return NULL;
12227 }
12228
12229
12230 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12231 PyObject *resultobj = 0;
12232 byte arg1 ;
12233 byte arg2 ;
12234 byte arg3 ;
12235 unsigned long result;
12236 unsigned char val1 ;
12237 int ecode1 = 0 ;
12238 unsigned char val2 ;
12239 int ecode2 = 0 ;
12240 unsigned char val3 ;
12241 int ecode3 = 0 ;
12242 PyObject * obj0 = 0 ;
12243 PyObject * obj1 = 0 ;
12244 PyObject * obj2 = 0 ;
12245 char * kwnames[] = {
12246 (char *) "r",(char *) "g",(char *) "b", NULL
12247 };
12248
12249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12250 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12251 if (!SWIG_IsOK(ecode1)) {
12252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12253 }
12254 arg1 = static_cast< byte >(val1);
12255 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12256 if (!SWIG_IsOK(ecode2)) {
12257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12258 }
12259 arg2 = static_cast< byte >(val2);
12260 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12261 if (!SWIG_IsOK(ecode3)) {
12262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12263 }
12264 arg3 = static_cast< byte >(val3);
12265 {
12266 PyThreadState* __tstate = wxPyBeginAllowThreads();
12267 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12268 wxPyEndAllowThreads(__tstate);
12269 if (PyErr_Occurred()) SWIG_fail;
12270 }
12271 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12272 return resultobj;
12273 fail:
12274 return NULL;
12275 }
12276
12277
12278 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12279 PyObject *resultobj = 0;
12280 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12281 byte *arg2 = (byte *) 0 ;
12282 byte *arg3 = (byte *) 0 ;
12283 byte *arg4 = (byte *) 0 ;
12284 byte arg5 = (byte) 1 ;
12285 byte arg6 = (byte) 0 ;
12286 byte arg7 = (byte) 0 ;
12287 bool result;
12288 void *argp1 = 0 ;
12289 int res1 = 0 ;
12290 byte temp2 ;
12291 int res2 = SWIG_TMPOBJ ;
12292 byte temp3 ;
12293 int res3 = SWIG_TMPOBJ ;
12294 byte temp4 ;
12295 int res4 = SWIG_TMPOBJ ;
12296 unsigned char val5 ;
12297 int ecode5 = 0 ;
12298 unsigned char val6 ;
12299 int ecode6 = 0 ;
12300 unsigned char val7 ;
12301 int ecode7 = 0 ;
12302 PyObject * obj0 = 0 ;
12303 PyObject * obj1 = 0 ;
12304 PyObject * obj2 = 0 ;
12305 PyObject * obj3 = 0 ;
12306 char * kwnames[] = {
12307 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12308 };
12309
12310 arg2 = &temp2;
12311 arg3 = &temp3;
12312 arg4 = &temp4;
12313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12315 if (!SWIG_IsOK(res1)) {
12316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12317 }
12318 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12319 if (obj1) {
12320 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12321 if (!SWIG_IsOK(ecode5)) {
12322 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12323 }
12324 arg5 = static_cast< byte >(val5);
12325 }
12326 if (obj2) {
12327 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12328 if (!SWIG_IsOK(ecode6)) {
12329 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12330 }
12331 arg6 = static_cast< byte >(val6);
12332 }
12333 if (obj3) {
12334 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12335 if (!SWIG_IsOK(ecode7)) {
12336 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12337 }
12338 arg7 = static_cast< byte >(val7);
12339 }
12340 {
12341 PyThreadState* __tstate = wxPyBeginAllowThreads();
12342 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12343 wxPyEndAllowThreads(__tstate);
12344 if (PyErr_Occurred()) SWIG_fail;
12345 }
12346 {
12347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12348 }
12349 if (SWIG_IsTmpObj(res2)) {
12350 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12351 } else {
12352 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12353 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12354 }
12355 if (SWIG_IsTmpObj(res3)) {
12356 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12357 } else {
12358 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12359 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12360 }
12361 if (SWIG_IsTmpObj(res4)) {
12362 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12363 } else {
12364 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12366 }
12367 return resultobj;
12368 fail:
12369 return NULL;
12370 }
12371
12372
12373 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12374 PyObject *resultobj = 0;
12375 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12376 unsigned long arg2 ;
12377 unsigned long result;
12378 void *argp1 = 0 ;
12379 int res1 = 0 ;
12380 unsigned long val2 ;
12381 int ecode2 = 0 ;
12382 PyObject * obj0 = 0 ;
12383 PyObject * obj1 = 0 ;
12384 char * kwnames[] = {
12385 (char *) "self",(char *) "key", NULL
12386 };
12387
12388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12390 if (!SWIG_IsOK(res1)) {
12391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12392 }
12393 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12394 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12395 if (!SWIG_IsOK(ecode2)) {
12396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12397 }
12398 arg2 = static_cast< unsigned long >(val2);
12399 {
12400 PyThreadState* __tstate = wxPyBeginAllowThreads();
12401 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12402 wxPyEndAllowThreads(__tstate);
12403 if (PyErr_Occurred()) SWIG_fail;
12404 }
12405 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12406 return resultobj;
12407 fail:
12408 return NULL;
12409 }
12410
12411
12412 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12413 PyObject *resultobj = 0;
12414 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12415 byte arg2 ;
12416 byte arg3 ;
12417 byte arg4 ;
12418 unsigned long result;
12419 void *argp1 = 0 ;
12420 int res1 = 0 ;
12421 unsigned char val2 ;
12422 int ecode2 = 0 ;
12423 unsigned char val3 ;
12424 int ecode3 = 0 ;
12425 unsigned char val4 ;
12426 int ecode4 = 0 ;
12427 PyObject * obj0 = 0 ;
12428 PyObject * obj1 = 0 ;
12429 PyObject * obj2 = 0 ;
12430 PyObject * obj3 = 0 ;
12431 char * kwnames[] = {
12432 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12433 };
12434
12435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12437 if (!SWIG_IsOK(res1)) {
12438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12439 }
12440 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12441 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12442 if (!SWIG_IsOK(ecode2)) {
12443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12444 }
12445 arg2 = static_cast< byte >(val2);
12446 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12447 if (!SWIG_IsOK(ecode3)) {
12448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12449 }
12450 arg3 = static_cast< byte >(val3);
12451 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12452 if (!SWIG_IsOK(ecode4)) {
12453 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12454 }
12455 arg4 = static_cast< byte >(val4);
12456 {
12457 PyThreadState* __tstate = wxPyBeginAllowThreads();
12458 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12459 wxPyEndAllowThreads(__tstate);
12460 if (PyErr_Occurred()) SWIG_fail;
12461 }
12462 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12463 return resultobj;
12464 fail:
12465 return NULL;
12466 }
12467
12468
12469 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12470 PyObject *resultobj = 0;
12471 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12472 wxColour *arg2 = 0 ;
12473 unsigned long result;
12474 void *argp1 = 0 ;
12475 int res1 = 0 ;
12476 wxColour temp2 ;
12477 PyObject * obj0 = 0 ;
12478 PyObject * obj1 = 0 ;
12479 char * kwnames[] = {
12480 (char *) "self",(char *) "colour", NULL
12481 };
12482
12483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12485 if (!SWIG_IsOK(res1)) {
12486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12487 }
12488 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12489 {
12490 arg2 = &temp2;
12491 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12492 }
12493 {
12494 PyThreadState* __tstate = wxPyBeginAllowThreads();
12495 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12496 wxPyEndAllowThreads(__tstate);
12497 if (PyErr_Occurred()) SWIG_fail;
12498 }
12499 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12500 return resultobj;
12501 fail:
12502 return NULL;
12503 }
12504
12505
12506 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12507 PyObject *obj;
12508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12509 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12510 return SWIG_Py_Void();
12511 }
12512
12513 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12514 return SWIG_Python_InitShadowInstance(args);
12515 }
12516
12517 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12518 PyObject *resultobj = 0;
12519 byte arg1 = (byte) 0 ;
12520 byte arg2 = (byte) 0 ;
12521 byte arg3 = (byte) 0 ;
12522 wxImage_RGBValue *result = 0 ;
12523 unsigned char val1 ;
12524 int ecode1 = 0 ;
12525 unsigned char val2 ;
12526 int ecode2 = 0 ;
12527 unsigned char val3 ;
12528 int ecode3 = 0 ;
12529 PyObject * obj0 = 0 ;
12530 PyObject * obj1 = 0 ;
12531 PyObject * obj2 = 0 ;
12532 char * kwnames[] = {
12533 (char *) "r",(char *) "g",(char *) "b", NULL
12534 };
12535
12536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12537 if (obj0) {
12538 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12539 if (!SWIG_IsOK(ecode1)) {
12540 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12541 }
12542 arg1 = static_cast< byte >(val1);
12543 }
12544 if (obj1) {
12545 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12546 if (!SWIG_IsOK(ecode2)) {
12547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12548 }
12549 arg2 = static_cast< byte >(val2);
12550 }
12551 if (obj2) {
12552 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12553 if (!SWIG_IsOK(ecode3)) {
12554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12555 }
12556 arg3 = static_cast< byte >(val3);
12557 }
12558 {
12559 PyThreadState* __tstate = wxPyBeginAllowThreads();
12560 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12561 wxPyEndAllowThreads(__tstate);
12562 if (PyErr_Occurred()) SWIG_fail;
12563 }
12564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12565 return resultobj;
12566 fail:
12567 return NULL;
12568 }
12569
12570
12571 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12572 PyObject *resultobj = 0;
12573 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12574 byte arg2 ;
12575 void *argp1 = 0 ;
12576 int res1 = 0 ;
12577 unsigned char val2 ;
12578 int ecode2 = 0 ;
12579 PyObject *swig_obj[2] ;
12580
12581 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12583 if (!SWIG_IsOK(res1)) {
12584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12585 }
12586 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12587 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12588 if (!SWIG_IsOK(ecode2)) {
12589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12590 }
12591 arg2 = static_cast< byte >(val2);
12592 if (arg1) (arg1)->red = arg2;
12593
12594 resultobj = SWIG_Py_Void();
12595 return resultobj;
12596 fail:
12597 return NULL;
12598 }
12599
12600
12601 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12602 PyObject *resultobj = 0;
12603 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12604 byte result;
12605 void *argp1 = 0 ;
12606 int res1 = 0 ;
12607 PyObject *swig_obj[1] ;
12608
12609 if (!args) SWIG_fail;
12610 swig_obj[0] = args;
12611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12612 if (!SWIG_IsOK(res1)) {
12613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12614 }
12615 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12616 result = (byte) ((arg1)->red);
12617 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12618 return resultobj;
12619 fail:
12620 return NULL;
12621 }
12622
12623
12624 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12625 PyObject *resultobj = 0;
12626 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12627 byte arg2 ;
12628 void *argp1 = 0 ;
12629 int res1 = 0 ;
12630 unsigned char val2 ;
12631 int ecode2 = 0 ;
12632 PyObject *swig_obj[2] ;
12633
12634 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12636 if (!SWIG_IsOK(res1)) {
12637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12638 }
12639 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12640 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12641 if (!SWIG_IsOK(ecode2)) {
12642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12643 }
12644 arg2 = static_cast< byte >(val2);
12645 if (arg1) (arg1)->green = arg2;
12646
12647 resultobj = SWIG_Py_Void();
12648 return resultobj;
12649 fail:
12650 return NULL;
12651 }
12652
12653
12654 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12655 PyObject *resultobj = 0;
12656 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12657 byte result;
12658 void *argp1 = 0 ;
12659 int res1 = 0 ;
12660 PyObject *swig_obj[1] ;
12661
12662 if (!args) SWIG_fail;
12663 swig_obj[0] = args;
12664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12665 if (!SWIG_IsOK(res1)) {
12666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12667 }
12668 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12669 result = (byte) ((arg1)->green);
12670 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12671 return resultobj;
12672 fail:
12673 return NULL;
12674 }
12675
12676
12677 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12678 PyObject *resultobj = 0;
12679 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12680 byte arg2 ;
12681 void *argp1 = 0 ;
12682 int res1 = 0 ;
12683 unsigned char val2 ;
12684 int ecode2 = 0 ;
12685 PyObject *swig_obj[2] ;
12686
12687 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12689 if (!SWIG_IsOK(res1)) {
12690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12691 }
12692 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12693 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12694 if (!SWIG_IsOK(ecode2)) {
12695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12696 }
12697 arg2 = static_cast< byte >(val2);
12698 if (arg1) (arg1)->blue = arg2;
12699
12700 resultobj = SWIG_Py_Void();
12701 return resultobj;
12702 fail:
12703 return NULL;
12704 }
12705
12706
12707 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12708 PyObject *resultobj = 0;
12709 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12710 byte result;
12711 void *argp1 = 0 ;
12712 int res1 = 0 ;
12713 PyObject *swig_obj[1] ;
12714
12715 if (!args) SWIG_fail;
12716 swig_obj[0] = args;
12717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12718 if (!SWIG_IsOK(res1)) {
12719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12720 }
12721 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12722 result = (byte) ((arg1)->blue);
12723 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12724 return resultobj;
12725 fail:
12726 return NULL;
12727 }
12728
12729
12730 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12731 PyObject *obj;
12732 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12733 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12734 return SWIG_Py_Void();
12735 }
12736
12737 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12738 return SWIG_Python_InitShadowInstance(args);
12739 }
12740
12741 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12742 PyObject *resultobj = 0;
12743 double arg1 = (double) 0.0 ;
12744 double arg2 = (double) 0.0 ;
12745 double arg3 = (double) 0.0 ;
12746 wxImage_HSVValue *result = 0 ;
12747 double val1 ;
12748 int ecode1 = 0 ;
12749 double val2 ;
12750 int ecode2 = 0 ;
12751 double val3 ;
12752 int ecode3 = 0 ;
12753 PyObject * obj0 = 0 ;
12754 PyObject * obj1 = 0 ;
12755 PyObject * obj2 = 0 ;
12756 char * kwnames[] = {
12757 (char *) "h",(char *) "s",(char *) "v", NULL
12758 };
12759
12760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12761 if (obj0) {
12762 ecode1 = SWIG_AsVal_double(obj0, &val1);
12763 if (!SWIG_IsOK(ecode1)) {
12764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12765 }
12766 arg1 = static_cast< double >(val1);
12767 }
12768 if (obj1) {
12769 ecode2 = SWIG_AsVal_double(obj1, &val2);
12770 if (!SWIG_IsOK(ecode2)) {
12771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12772 }
12773 arg2 = static_cast< double >(val2);
12774 }
12775 if (obj2) {
12776 ecode3 = SWIG_AsVal_double(obj2, &val3);
12777 if (!SWIG_IsOK(ecode3)) {
12778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12779 }
12780 arg3 = static_cast< double >(val3);
12781 }
12782 {
12783 PyThreadState* __tstate = wxPyBeginAllowThreads();
12784 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12785 wxPyEndAllowThreads(__tstate);
12786 if (PyErr_Occurred()) SWIG_fail;
12787 }
12788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12789 return resultobj;
12790 fail:
12791 return NULL;
12792 }
12793
12794
12795 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12796 PyObject *resultobj = 0;
12797 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12798 double arg2 ;
12799 void *argp1 = 0 ;
12800 int res1 = 0 ;
12801 double val2 ;
12802 int ecode2 = 0 ;
12803 PyObject *swig_obj[2] ;
12804
12805 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12807 if (!SWIG_IsOK(res1)) {
12808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12809 }
12810 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12811 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12812 if (!SWIG_IsOK(ecode2)) {
12813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12814 }
12815 arg2 = static_cast< double >(val2);
12816 if (arg1) (arg1)->hue = arg2;
12817
12818 resultobj = SWIG_Py_Void();
12819 return resultobj;
12820 fail:
12821 return NULL;
12822 }
12823
12824
12825 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12826 PyObject *resultobj = 0;
12827 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12828 double result;
12829 void *argp1 = 0 ;
12830 int res1 = 0 ;
12831 PyObject *swig_obj[1] ;
12832
12833 if (!args) SWIG_fail;
12834 swig_obj[0] = args;
12835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12836 if (!SWIG_IsOK(res1)) {
12837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12838 }
12839 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12840 result = (double) ((arg1)->hue);
12841 resultobj = SWIG_From_double(static_cast< double >(result));
12842 return resultobj;
12843 fail:
12844 return NULL;
12845 }
12846
12847
12848 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12849 PyObject *resultobj = 0;
12850 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12851 double arg2 ;
12852 void *argp1 = 0 ;
12853 int res1 = 0 ;
12854 double val2 ;
12855 int ecode2 = 0 ;
12856 PyObject *swig_obj[2] ;
12857
12858 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12860 if (!SWIG_IsOK(res1)) {
12861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12862 }
12863 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12864 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12865 if (!SWIG_IsOK(ecode2)) {
12866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12867 }
12868 arg2 = static_cast< double >(val2);
12869 if (arg1) (arg1)->saturation = arg2;
12870
12871 resultobj = SWIG_Py_Void();
12872 return resultobj;
12873 fail:
12874 return NULL;
12875 }
12876
12877
12878 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12879 PyObject *resultobj = 0;
12880 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12881 double result;
12882 void *argp1 = 0 ;
12883 int res1 = 0 ;
12884 PyObject *swig_obj[1] ;
12885
12886 if (!args) SWIG_fail;
12887 swig_obj[0] = args;
12888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12889 if (!SWIG_IsOK(res1)) {
12890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12891 }
12892 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12893 result = (double) ((arg1)->saturation);
12894 resultobj = SWIG_From_double(static_cast< double >(result));
12895 return resultobj;
12896 fail:
12897 return NULL;
12898 }
12899
12900
12901 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12902 PyObject *resultobj = 0;
12903 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12904 double arg2 ;
12905 void *argp1 = 0 ;
12906 int res1 = 0 ;
12907 double val2 ;
12908 int ecode2 = 0 ;
12909 PyObject *swig_obj[2] ;
12910
12911 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12913 if (!SWIG_IsOK(res1)) {
12914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12915 }
12916 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12917 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12918 if (!SWIG_IsOK(ecode2)) {
12919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12920 }
12921 arg2 = static_cast< double >(val2);
12922 if (arg1) (arg1)->value = arg2;
12923
12924 resultobj = SWIG_Py_Void();
12925 return resultobj;
12926 fail:
12927 return NULL;
12928 }
12929
12930
12931 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12932 PyObject *resultobj = 0;
12933 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12934 double result;
12935 void *argp1 = 0 ;
12936 int res1 = 0 ;
12937 PyObject *swig_obj[1] ;
12938
12939 if (!args) SWIG_fail;
12940 swig_obj[0] = args;
12941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12942 if (!SWIG_IsOK(res1)) {
12943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12944 }
12945 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12946 result = (double) ((arg1)->value);
12947 resultobj = SWIG_From_double(static_cast< double >(result));
12948 return resultobj;
12949 fail:
12950 return NULL;
12951 }
12952
12953
12954 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12955 PyObject *obj;
12956 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12957 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12958 return SWIG_Py_Void();
12959 }
12960
12961 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12962 return SWIG_Python_InitShadowInstance(args);
12963 }
12964
12965 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12966 PyObject *resultobj = 0;
12967 wxString *arg1 = 0 ;
12968 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12969 int arg3 = (int) -1 ;
12970 wxImage *result = 0 ;
12971 bool temp1 = false ;
12972 long val2 ;
12973 int ecode2 = 0 ;
12974 int val3 ;
12975 int ecode3 = 0 ;
12976 PyObject * obj0 = 0 ;
12977 PyObject * obj1 = 0 ;
12978 PyObject * obj2 = 0 ;
12979 char * kwnames[] = {
12980 (char *) "name",(char *) "type",(char *) "index", NULL
12981 };
12982
12983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12984 {
12985 arg1 = wxString_in_helper(obj0);
12986 if (arg1 == NULL) SWIG_fail;
12987 temp1 = true;
12988 }
12989 if (obj1) {
12990 ecode2 = SWIG_AsVal_long(obj1, &val2);
12991 if (!SWIG_IsOK(ecode2)) {
12992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12993 }
12994 arg2 = static_cast< long >(val2);
12995 }
12996 if (obj2) {
12997 ecode3 = SWIG_AsVal_int(obj2, &val3);
12998 if (!SWIG_IsOK(ecode3)) {
12999 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13000 }
13001 arg3 = static_cast< int >(val3);
13002 }
13003 {
13004 PyThreadState* __tstate = wxPyBeginAllowThreads();
13005 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13006 wxPyEndAllowThreads(__tstate);
13007 if (PyErr_Occurred()) SWIG_fail;
13008 }
13009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13010 {
13011 if (temp1)
13012 delete arg1;
13013 }
13014 return resultobj;
13015 fail:
13016 {
13017 if (temp1)
13018 delete arg1;
13019 }
13020 return NULL;
13021 }
13022
13023
13024 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13025 PyObject *resultobj = 0;
13026 wxImage *arg1 = (wxImage *) 0 ;
13027 void *argp1 = 0 ;
13028 int res1 = 0 ;
13029 PyObject *swig_obj[1] ;
13030
13031 if (!args) SWIG_fail;
13032 swig_obj[0] = args;
13033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13034 if (!SWIG_IsOK(res1)) {
13035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13036 }
13037 arg1 = reinterpret_cast< wxImage * >(argp1);
13038 {
13039 PyThreadState* __tstate = wxPyBeginAllowThreads();
13040 delete arg1;
13041
13042 wxPyEndAllowThreads(__tstate);
13043 if (PyErr_Occurred()) SWIG_fail;
13044 }
13045 resultobj = SWIG_Py_Void();
13046 return resultobj;
13047 fail:
13048 return NULL;
13049 }
13050
13051
13052 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13053 PyObject *resultobj = 0;
13054 wxString *arg1 = 0 ;
13055 wxString *arg2 = 0 ;
13056 int arg3 = (int) -1 ;
13057 wxImage *result = 0 ;
13058 bool temp1 = false ;
13059 bool temp2 = false ;
13060 int val3 ;
13061 int ecode3 = 0 ;
13062 PyObject * obj0 = 0 ;
13063 PyObject * obj1 = 0 ;
13064 PyObject * obj2 = 0 ;
13065 char * kwnames[] = {
13066 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13067 };
13068
13069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13070 {
13071 arg1 = wxString_in_helper(obj0);
13072 if (arg1 == NULL) SWIG_fail;
13073 temp1 = true;
13074 }
13075 {
13076 arg2 = wxString_in_helper(obj1);
13077 if (arg2 == NULL) SWIG_fail;
13078 temp2 = true;
13079 }
13080 if (obj2) {
13081 ecode3 = SWIG_AsVal_int(obj2, &val3);
13082 if (!SWIG_IsOK(ecode3)) {
13083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13084 }
13085 arg3 = static_cast< int >(val3);
13086 }
13087 {
13088 PyThreadState* __tstate = wxPyBeginAllowThreads();
13089 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13090 wxPyEndAllowThreads(__tstate);
13091 if (PyErr_Occurred()) SWIG_fail;
13092 }
13093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13094 {
13095 if (temp1)
13096 delete arg1;
13097 }
13098 {
13099 if (temp2)
13100 delete arg2;
13101 }
13102 return resultobj;
13103 fail:
13104 {
13105 if (temp1)
13106 delete arg1;
13107 }
13108 {
13109 if (temp2)
13110 delete arg2;
13111 }
13112 return NULL;
13113 }
13114
13115
13116 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13117 PyObject *resultobj = 0;
13118 wxInputStream *arg1 = 0 ;
13119 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13120 int arg3 = (int) -1 ;
13121 wxImage *result = 0 ;
13122 wxPyInputStream *temp1 ;
13123 bool created1 ;
13124 long val2 ;
13125 int ecode2 = 0 ;
13126 int val3 ;
13127 int ecode3 = 0 ;
13128 PyObject * obj0 = 0 ;
13129 PyObject * obj1 = 0 ;
13130 PyObject * obj2 = 0 ;
13131 char * kwnames[] = {
13132 (char *) "stream",(char *) "type",(char *) "index", NULL
13133 };
13134
13135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13136 {
13137 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13138 arg1 = temp1->m_wxis;
13139 created1 = false;
13140 } else {
13141 PyErr_Clear(); // clear the failure of the wxPyConvert above
13142 arg1 = wxPyCBInputStream_create(obj0, false);
13143 if (arg1 == NULL) {
13144 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13145 SWIG_fail;
13146 }
13147 created1 = true;
13148 }
13149 }
13150 if (obj1) {
13151 ecode2 = SWIG_AsVal_long(obj1, &val2);
13152 if (!SWIG_IsOK(ecode2)) {
13153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13154 }
13155 arg2 = static_cast< long >(val2);
13156 }
13157 if (obj2) {
13158 ecode3 = SWIG_AsVal_int(obj2, &val3);
13159 if (!SWIG_IsOK(ecode3)) {
13160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13161 }
13162 arg3 = static_cast< int >(val3);
13163 }
13164 {
13165 PyThreadState* __tstate = wxPyBeginAllowThreads();
13166 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13167 wxPyEndAllowThreads(__tstate);
13168 if (PyErr_Occurred()) SWIG_fail;
13169 }
13170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13171 {
13172 if (created1) delete arg1;
13173 }
13174 return resultobj;
13175 fail:
13176 {
13177 if (created1) delete arg1;
13178 }
13179 return NULL;
13180 }
13181
13182
13183 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13184 PyObject *resultobj = 0;
13185 wxInputStream *arg1 = 0 ;
13186 wxString *arg2 = 0 ;
13187 int arg3 = (int) -1 ;
13188 wxImage *result = 0 ;
13189 wxPyInputStream *temp1 ;
13190 bool created1 ;
13191 bool temp2 = false ;
13192 int val3 ;
13193 int ecode3 = 0 ;
13194 PyObject * obj0 = 0 ;
13195 PyObject * obj1 = 0 ;
13196 PyObject * obj2 = 0 ;
13197 char * kwnames[] = {
13198 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13199 };
13200
13201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13202 {
13203 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13204 arg1 = temp1->m_wxis;
13205 created1 = false;
13206 } else {
13207 PyErr_Clear(); // clear the failure of the wxPyConvert above
13208 arg1 = wxPyCBInputStream_create(obj0, false);
13209 if (arg1 == NULL) {
13210 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13211 SWIG_fail;
13212 }
13213 created1 = true;
13214 }
13215 }
13216 {
13217 arg2 = wxString_in_helper(obj1);
13218 if (arg2 == NULL) SWIG_fail;
13219 temp2 = true;
13220 }
13221 if (obj2) {
13222 ecode3 = SWIG_AsVal_int(obj2, &val3);
13223 if (!SWIG_IsOK(ecode3)) {
13224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13225 }
13226 arg3 = static_cast< int >(val3);
13227 }
13228 {
13229 PyThreadState* __tstate = wxPyBeginAllowThreads();
13230 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13231 wxPyEndAllowThreads(__tstate);
13232 if (PyErr_Occurred()) SWIG_fail;
13233 }
13234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13235 {
13236 if (created1) delete arg1;
13237 }
13238 {
13239 if (temp2)
13240 delete arg2;
13241 }
13242 return resultobj;
13243 fail:
13244 {
13245 if (created1) delete arg1;
13246 }
13247 {
13248 if (temp2)
13249 delete arg2;
13250 }
13251 return NULL;
13252 }
13253
13254
13255 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13256 PyObject *resultobj = 0;
13257 int arg1 = (int) 0 ;
13258 int arg2 = (int) 0 ;
13259 bool arg3 = (bool) true ;
13260 wxImage *result = 0 ;
13261 int val1 ;
13262 int ecode1 = 0 ;
13263 int val2 ;
13264 int ecode2 = 0 ;
13265 bool val3 ;
13266 int ecode3 = 0 ;
13267 PyObject * obj0 = 0 ;
13268 PyObject * obj1 = 0 ;
13269 PyObject * obj2 = 0 ;
13270 char * kwnames[] = {
13271 (char *) "width",(char *) "height",(char *) "clear", NULL
13272 };
13273
13274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13275 if (obj0) {
13276 ecode1 = SWIG_AsVal_int(obj0, &val1);
13277 if (!SWIG_IsOK(ecode1)) {
13278 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13279 }
13280 arg1 = static_cast< int >(val1);
13281 }
13282 if (obj1) {
13283 ecode2 = SWIG_AsVal_int(obj1, &val2);
13284 if (!SWIG_IsOK(ecode2)) {
13285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13286 }
13287 arg2 = static_cast< int >(val2);
13288 }
13289 if (obj2) {
13290 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13291 if (!SWIG_IsOK(ecode3)) {
13292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13293 }
13294 arg3 = static_cast< bool >(val3);
13295 }
13296 {
13297 PyThreadState* __tstate = wxPyBeginAllowThreads();
13298 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13299 wxPyEndAllowThreads(__tstate);
13300 if (PyErr_Occurred()) SWIG_fail;
13301 }
13302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13303 return resultobj;
13304 fail:
13305 return NULL;
13306 }
13307
13308
13309 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13310 PyObject *resultobj = 0;
13311 wxBitmap *arg1 = 0 ;
13312 wxImage *result = 0 ;
13313 void *argp1 = 0 ;
13314 int res1 = 0 ;
13315 PyObject * obj0 = 0 ;
13316 char * kwnames[] = {
13317 (char *) "bitmap", NULL
13318 };
13319
13320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13321 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13322 if (!SWIG_IsOK(res1)) {
13323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13324 }
13325 if (!argp1) {
13326 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13327 }
13328 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13329 {
13330 if (!wxPyCheckForApp()) SWIG_fail;
13331 PyThreadState* __tstate = wxPyBeginAllowThreads();
13332 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13333 wxPyEndAllowThreads(__tstate);
13334 if (PyErr_Occurred()) SWIG_fail;
13335 }
13336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13337 return resultobj;
13338 fail:
13339 return NULL;
13340 }
13341
13342
13343 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13344 PyObject *resultobj = 0;
13345 int arg1 ;
13346 int arg2 ;
13347 buffer arg3 ;
13348 int arg4 ;
13349 wxImage *result = 0 ;
13350 int val1 ;
13351 int ecode1 = 0 ;
13352 int val2 ;
13353 int ecode2 = 0 ;
13354 PyObject * obj0 = 0 ;
13355 PyObject * obj1 = 0 ;
13356 PyObject * obj2 = 0 ;
13357 char * kwnames[] = {
13358 (char *) "width",(char *) "height",(char *) "data", NULL
13359 };
13360
13361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13362 ecode1 = SWIG_AsVal_int(obj0, &val1);
13363 if (!SWIG_IsOK(ecode1)) {
13364 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13365 }
13366 arg1 = static_cast< int >(val1);
13367 ecode2 = SWIG_AsVal_int(obj1, &val2);
13368 if (!SWIG_IsOK(ecode2)) {
13369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13370 }
13371 arg2 = static_cast< int >(val2);
13372 {
13373 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13374 }
13375 {
13376 PyThreadState* __tstate = wxPyBeginAllowThreads();
13377 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13378 wxPyEndAllowThreads(__tstate);
13379 if (PyErr_Occurred()) SWIG_fail;
13380 }
13381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13382 return resultobj;
13383 fail:
13384 return NULL;
13385 }
13386
13387
13388 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13389 PyObject *resultobj = 0;
13390 int arg1 ;
13391 int arg2 ;
13392 buffer arg3 ;
13393 int arg4 ;
13394 buffer arg5 ;
13395 int arg6 ;
13396 wxImage *result = 0 ;
13397 int val1 ;
13398 int ecode1 = 0 ;
13399 int val2 ;
13400 int ecode2 = 0 ;
13401 PyObject * obj0 = 0 ;
13402 PyObject * obj1 = 0 ;
13403 PyObject * obj2 = 0 ;
13404 PyObject * obj3 = 0 ;
13405 char * kwnames[] = {
13406 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13407 };
13408
13409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13410 ecode1 = SWIG_AsVal_int(obj0, &val1);
13411 if (!SWIG_IsOK(ecode1)) {
13412 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13413 }
13414 arg1 = static_cast< int >(val1);
13415 ecode2 = SWIG_AsVal_int(obj1, &val2);
13416 if (!SWIG_IsOK(ecode2)) {
13417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13418 }
13419 arg2 = static_cast< int >(val2);
13420 {
13421 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13422 }
13423 {
13424 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13425 }
13426 {
13427 PyThreadState* __tstate = wxPyBeginAllowThreads();
13428 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13429 wxPyEndAllowThreads(__tstate);
13430 if (PyErr_Occurred()) SWIG_fail;
13431 }
13432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13433 return resultobj;
13434 fail:
13435 return NULL;
13436 }
13437
13438
13439 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13440 PyObject *resultobj = 0;
13441 wxImage *arg1 = (wxImage *) 0 ;
13442 int arg2 ;
13443 int arg3 ;
13444 bool arg4 = (bool) true ;
13445 void *argp1 = 0 ;
13446 int res1 = 0 ;
13447 int val2 ;
13448 int ecode2 = 0 ;
13449 int val3 ;
13450 int ecode3 = 0 ;
13451 bool val4 ;
13452 int ecode4 = 0 ;
13453 PyObject * obj0 = 0 ;
13454 PyObject * obj1 = 0 ;
13455 PyObject * obj2 = 0 ;
13456 PyObject * obj3 = 0 ;
13457 char * kwnames[] = {
13458 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13459 };
13460
13461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13463 if (!SWIG_IsOK(res1)) {
13464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13465 }
13466 arg1 = reinterpret_cast< wxImage * >(argp1);
13467 ecode2 = SWIG_AsVal_int(obj1, &val2);
13468 if (!SWIG_IsOK(ecode2)) {
13469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13470 }
13471 arg2 = static_cast< int >(val2);
13472 ecode3 = SWIG_AsVal_int(obj2, &val3);
13473 if (!SWIG_IsOK(ecode3)) {
13474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13475 }
13476 arg3 = static_cast< int >(val3);
13477 if (obj3) {
13478 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13479 if (!SWIG_IsOK(ecode4)) {
13480 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13481 }
13482 arg4 = static_cast< bool >(val4);
13483 }
13484 {
13485 PyThreadState* __tstate = wxPyBeginAllowThreads();
13486 (arg1)->Create(arg2,arg3,arg4);
13487 wxPyEndAllowThreads(__tstate);
13488 if (PyErr_Occurred()) SWIG_fail;
13489 }
13490 resultobj = SWIG_Py_Void();
13491 return resultobj;
13492 fail:
13493 return NULL;
13494 }
13495
13496
13497 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13498 PyObject *resultobj = 0;
13499 wxImage *arg1 = (wxImage *) 0 ;
13500 void *argp1 = 0 ;
13501 int res1 = 0 ;
13502 PyObject *swig_obj[1] ;
13503
13504 if (!args) SWIG_fail;
13505 swig_obj[0] = args;
13506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13507 if (!SWIG_IsOK(res1)) {
13508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13509 }
13510 arg1 = reinterpret_cast< wxImage * >(argp1);
13511 {
13512 PyThreadState* __tstate = wxPyBeginAllowThreads();
13513 (arg1)->Destroy();
13514 wxPyEndAllowThreads(__tstate);
13515 if (PyErr_Occurred()) SWIG_fail;
13516 }
13517 resultobj = SWIG_Py_Void();
13518 return resultobj;
13519 fail:
13520 return NULL;
13521 }
13522
13523
13524 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13525 PyObject *resultobj = 0;
13526 wxImage *arg1 = (wxImage *) 0 ;
13527 int arg2 ;
13528 int arg3 ;
13529 SwigValueWrapper<wxImage > result;
13530 void *argp1 = 0 ;
13531 int res1 = 0 ;
13532 int val2 ;
13533 int ecode2 = 0 ;
13534 int val3 ;
13535 int ecode3 = 0 ;
13536 PyObject * obj0 = 0 ;
13537 PyObject * obj1 = 0 ;
13538 PyObject * obj2 = 0 ;
13539 char * kwnames[] = {
13540 (char *) "self",(char *) "width",(char *) "height", NULL
13541 };
13542
13543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13545 if (!SWIG_IsOK(res1)) {
13546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13547 }
13548 arg1 = reinterpret_cast< wxImage * >(argp1);
13549 ecode2 = SWIG_AsVal_int(obj1, &val2);
13550 if (!SWIG_IsOK(ecode2)) {
13551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13552 }
13553 arg2 = static_cast< int >(val2);
13554 ecode3 = SWIG_AsVal_int(obj2, &val3);
13555 if (!SWIG_IsOK(ecode3)) {
13556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13557 }
13558 arg3 = static_cast< int >(val3);
13559 {
13560 PyThreadState* __tstate = wxPyBeginAllowThreads();
13561 result = (arg1)->Scale(arg2,arg3);
13562 wxPyEndAllowThreads(__tstate);
13563 if (PyErr_Occurred()) SWIG_fail;
13564 }
13565 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13566 return resultobj;
13567 fail:
13568 return NULL;
13569 }
13570
13571
13572 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13573 PyObject *resultobj = 0;
13574 wxImage *arg1 = (wxImage *) 0 ;
13575 int arg2 ;
13576 int arg3 ;
13577 SwigValueWrapper<wxImage > result;
13578 void *argp1 = 0 ;
13579 int res1 = 0 ;
13580 int val2 ;
13581 int ecode2 = 0 ;
13582 int val3 ;
13583 int ecode3 = 0 ;
13584 PyObject * obj0 = 0 ;
13585 PyObject * obj1 = 0 ;
13586 PyObject * obj2 = 0 ;
13587 char * kwnames[] = {
13588 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13589 };
13590
13591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13593 if (!SWIG_IsOK(res1)) {
13594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13595 }
13596 arg1 = reinterpret_cast< wxImage * >(argp1);
13597 ecode2 = SWIG_AsVal_int(obj1, &val2);
13598 if (!SWIG_IsOK(ecode2)) {
13599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13600 }
13601 arg2 = static_cast< int >(val2);
13602 ecode3 = SWIG_AsVal_int(obj2, &val3);
13603 if (!SWIG_IsOK(ecode3)) {
13604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13605 }
13606 arg3 = static_cast< int >(val3);
13607 {
13608 PyThreadState* __tstate = wxPyBeginAllowThreads();
13609 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13610 wxPyEndAllowThreads(__tstate);
13611 if (PyErr_Occurred()) SWIG_fail;
13612 }
13613 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13614 return resultobj;
13615 fail:
13616 return NULL;
13617 }
13618
13619
13620 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13621 PyObject *resultobj = 0;
13622 wxImage *arg1 = (wxImage *) 0 ;
13623 int arg2 ;
13624 int arg3 ;
13625 wxImage *result = 0 ;
13626 void *argp1 = 0 ;
13627 int res1 = 0 ;
13628 int val2 ;
13629 int ecode2 = 0 ;
13630 int val3 ;
13631 int ecode3 = 0 ;
13632 PyObject * obj0 = 0 ;
13633 PyObject * obj1 = 0 ;
13634 PyObject * obj2 = 0 ;
13635 char * kwnames[] = {
13636 (char *) "self",(char *) "width",(char *) "height", NULL
13637 };
13638
13639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13641 if (!SWIG_IsOK(res1)) {
13642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13643 }
13644 arg1 = reinterpret_cast< wxImage * >(argp1);
13645 ecode2 = SWIG_AsVal_int(obj1, &val2);
13646 if (!SWIG_IsOK(ecode2)) {
13647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13648 }
13649 arg2 = static_cast< int >(val2);
13650 ecode3 = SWIG_AsVal_int(obj2, &val3);
13651 if (!SWIG_IsOK(ecode3)) {
13652 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13653 }
13654 arg3 = static_cast< int >(val3);
13655 {
13656 PyThreadState* __tstate = wxPyBeginAllowThreads();
13657 {
13658 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13659 result = (wxImage *) &_result_ref;
13660 }
13661 wxPyEndAllowThreads(__tstate);
13662 if (PyErr_Occurred()) SWIG_fail;
13663 }
13664 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13665 return resultobj;
13666 fail:
13667 return NULL;
13668 }
13669
13670
13671 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13672 PyObject *resultobj = 0;
13673 wxImage *arg1 = (wxImage *) 0 ;
13674 wxSize *arg2 = 0 ;
13675 wxPoint *arg3 = 0 ;
13676 int arg4 = (int) -1 ;
13677 int arg5 = (int) -1 ;
13678 int arg6 = (int) -1 ;
13679 wxImage *result = 0 ;
13680 void *argp1 = 0 ;
13681 int res1 = 0 ;
13682 wxSize temp2 ;
13683 wxPoint temp3 ;
13684 int val4 ;
13685 int ecode4 = 0 ;
13686 int val5 ;
13687 int ecode5 = 0 ;
13688 int val6 ;
13689 int ecode6 = 0 ;
13690 PyObject * obj0 = 0 ;
13691 PyObject * obj1 = 0 ;
13692 PyObject * obj2 = 0 ;
13693 PyObject * obj3 = 0 ;
13694 PyObject * obj4 = 0 ;
13695 PyObject * obj5 = 0 ;
13696 char * kwnames[] = {
13697 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13698 };
13699
13700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13702 if (!SWIG_IsOK(res1)) {
13703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13704 }
13705 arg1 = reinterpret_cast< wxImage * >(argp1);
13706 {
13707 arg2 = &temp2;
13708 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13709 }
13710 {
13711 arg3 = &temp3;
13712 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13713 }
13714 if (obj3) {
13715 ecode4 = SWIG_AsVal_int(obj3, &val4);
13716 if (!SWIG_IsOK(ecode4)) {
13717 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13718 }
13719 arg4 = static_cast< int >(val4);
13720 }
13721 if (obj4) {
13722 ecode5 = SWIG_AsVal_int(obj4, &val5);
13723 if (!SWIG_IsOK(ecode5)) {
13724 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13725 }
13726 arg5 = static_cast< int >(val5);
13727 }
13728 if (obj5) {
13729 ecode6 = SWIG_AsVal_int(obj5, &val6);
13730 if (!SWIG_IsOK(ecode6)) {
13731 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13732 }
13733 arg6 = static_cast< int >(val6);
13734 }
13735 {
13736 PyThreadState* __tstate = wxPyBeginAllowThreads();
13737 {
13738 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13739 result = (wxImage *) &_result_ref;
13740 }
13741 wxPyEndAllowThreads(__tstate);
13742 if (PyErr_Occurred()) SWIG_fail;
13743 }
13744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13745 return resultobj;
13746 fail:
13747 return NULL;
13748 }
13749
13750
13751 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13752 PyObject *resultobj = 0;
13753 wxImage *arg1 = (wxImage *) 0 ;
13754 int arg2 ;
13755 int arg3 ;
13756 byte arg4 ;
13757 byte arg5 ;
13758 byte arg6 ;
13759 void *argp1 = 0 ;
13760 int res1 = 0 ;
13761 int val2 ;
13762 int ecode2 = 0 ;
13763 int val3 ;
13764 int ecode3 = 0 ;
13765 unsigned char val4 ;
13766 int ecode4 = 0 ;
13767 unsigned char val5 ;
13768 int ecode5 = 0 ;
13769 unsigned char val6 ;
13770 int ecode6 = 0 ;
13771 PyObject * obj0 = 0 ;
13772 PyObject * obj1 = 0 ;
13773 PyObject * obj2 = 0 ;
13774 PyObject * obj3 = 0 ;
13775 PyObject * obj4 = 0 ;
13776 PyObject * obj5 = 0 ;
13777 char * kwnames[] = {
13778 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13779 };
13780
13781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13783 if (!SWIG_IsOK(res1)) {
13784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13785 }
13786 arg1 = reinterpret_cast< wxImage * >(argp1);
13787 ecode2 = SWIG_AsVal_int(obj1, &val2);
13788 if (!SWIG_IsOK(ecode2)) {
13789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13790 }
13791 arg2 = static_cast< int >(val2);
13792 ecode3 = SWIG_AsVal_int(obj2, &val3);
13793 if (!SWIG_IsOK(ecode3)) {
13794 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13795 }
13796 arg3 = static_cast< int >(val3);
13797 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13798 if (!SWIG_IsOK(ecode4)) {
13799 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13800 }
13801 arg4 = static_cast< byte >(val4);
13802 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13803 if (!SWIG_IsOK(ecode5)) {
13804 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13805 }
13806 arg5 = static_cast< byte >(val5);
13807 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13808 if (!SWIG_IsOK(ecode6)) {
13809 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13810 }
13811 arg6 = static_cast< byte >(val6);
13812 {
13813 PyThreadState* __tstate = wxPyBeginAllowThreads();
13814 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13815 wxPyEndAllowThreads(__tstate);
13816 if (PyErr_Occurred()) SWIG_fail;
13817 }
13818 resultobj = SWIG_Py_Void();
13819 return resultobj;
13820 fail:
13821 return NULL;
13822 }
13823
13824
13825 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13826 PyObject *resultobj = 0;
13827 wxImage *arg1 = (wxImage *) 0 ;
13828 wxRect *arg2 = 0 ;
13829 byte arg3 ;
13830 byte arg4 ;
13831 byte arg5 ;
13832 void *argp1 = 0 ;
13833 int res1 = 0 ;
13834 wxRect temp2 ;
13835 unsigned char val3 ;
13836 int ecode3 = 0 ;
13837 unsigned char val4 ;
13838 int ecode4 = 0 ;
13839 unsigned char val5 ;
13840 int ecode5 = 0 ;
13841 PyObject * obj0 = 0 ;
13842 PyObject * obj1 = 0 ;
13843 PyObject * obj2 = 0 ;
13844 PyObject * obj3 = 0 ;
13845 PyObject * obj4 = 0 ;
13846 char * kwnames[] = {
13847 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13848 };
13849
13850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13852 if (!SWIG_IsOK(res1)) {
13853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13854 }
13855 arg1 = reinterpret_cast< wxImage * >(argp1);
13856 {
13857 arg2 = &temp2;
13858 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13859 }
13860 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13861 if (!SWIG_IsOK(ecode3)) {
13862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13863 }
13864 arg3 = static_cast< byte >(val3);
13865 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13866 if (!SWIG_IsOK(ecode4)) {
13867 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13868 }
13869 arg4 = static_cast< byte >(val4);
13870 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13871 if (!SWIG_IsOK(ecode5)) {
13872 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13873 }
13874 arg5 = static_cast< byte >(val5);
13875 {
13876 PyThreadState* __tstate = wxPyBeginAllowThreads();
13877 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13878 wxPyEndAllowThreads(__tstate);
13879 if (PyErr_Occurred()) SWIG_fail;
13880 }
13881 resultobj = SWIG_Py_Void();
13882 return resultobj;
13883 fail:
13884 return NULL;
13885 }
13886
13887
13888 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13889 PyObject *resultobj = 0;
13890 wxImage *arg1 = (wxImage *) 0 ;
13891 int arg2 ;
13892 int arg3 ;
13893 byte result;
13894 void *argp1 = 0 ;
13895 int res1 = 0 ;
13896 int val2 ;
13897 int ecode2 = 0 ;
13898 int val3 ;
13899 int ecode3 = 0 ;
13900 PyObject * obj0 = 0 ;
13901 PyObject * obj1 = 0 ;
13902 PyObject * obj2 = 0 ;
13903 char * kwnames[] = {
13904 (char *) "self",(char *) "x",(char *) "y", NULL
13905 };
13906
13907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13909 if (!SWIG_IsOK(res1)) {
13910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13911 }
13912 arg1 = reinterpret_cast< wxImage * >(argp1);
13913 ecode2 = SWIG_AsVal_int(obj1, &val2);
13914 if (!SWIG_IsOK(ecode2)) {
13915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13916 }
13917 arg2 = static_cast< int >(val2);
13918 ecode3 = SWIG_AsVal_int(obj2, &val3);
13919 if (!SWIG_IsOK(ecode3)) {
13920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13921 }
13922 arg3 = static_cast< int >(val3);
13923 {
13924 PyThreadState* __tstate = wxPyBeginAllowThreads();
13925 result = (byte)(arg1)->GetRed(arg2,arg3);
13926 wxPyEndAllowThreads(__tstate);
13927 if (PyErr_Occurred()) SWIG_fail;
13928 }
13929 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13930 return resultobj;
13931 fail:
13932 return NULL;
13933 }
13934
13935
13936 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13937 PyObject *resultobj = 0;
13938 wxImage *arg1 = (wxImage *) 0 ;
13939 int arg2 ;
13940 int arg3 ;
13941 byte result;
13942 void *argp1 = 0 ;
13943 int res1 = 0 ;
13944 int val2 ;
13945 int ecode2 = 0 ;
13946 int val3 ;
13947 int ecode3 = 0 ;
13948 PyObject * obj0 = 0 ;
13949 PyObject * obj1 = 0 ;
13950 PyObject * obj2 = 0 ;
13951 char * kwnames[] = {
13952 (char *) "self",(char *) "x",(char *) "y", NULL
13953 };
13954
13955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13957 if (!SWIG_IsOK(res1)) {
13958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13959 }
13960 arg1 = reinterpret_cast< wxImage * >(argp1);
13961 ecode2 = SWIG_AsVal_int(obj1, &val2);
13962 if (!SWIG_IsOK(ecode2)) {
13963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13964 }
13965 arg2 = static_cast< int >(val2);
13966 ecode3 = SWIG_AsVal_int(obj2, &val3);
13967 if (!SWIG_IsOK(ecode3)) {
13968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13969 }
13970 arg3 = static_cast< int >(val3);
13971 {
13972 PyThreadState* __tstate = wxPyBeginAllowThreads();
13973 result = (byte)(arg1)->GetGreen(arg2,arg3);
13974 wxPyEndAllowThreads(__tstate);
13975 if (PyErr_Occurred()) SWIG_fail;
13976 }
13977 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13978 return resultobj;
13979 fail:
13980 return NULL;
13981 }
13982
13983
13984 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13985 PyObject *resultobj = 0;
13986 wxImage *arg1 = (wxImage *) 0 ;
13987 int arg2 ;
13988 int arg3 ;
13989 byte result;
13990 void *argp1 = 0 ;
13991 int res1 = 0 ;
13992 int val2 ;
13993 int ecode2 = 0 ;
13994 int val3 ;
13995 int ecode3 = 0 ;
13996 PyObject * obj0 = 0 ;
13997 PyObject * obj1 = 0 ;
13998 PyObject * obj2 = 0 ;
13999 char * kwnames[] = {
14000 (char *) "self",(char *) "x",(char *) "y", NULL
14001 };
14002
14003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14005 if (!SWIG_IsOK(res1)) {
14006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14007 }
14008 arg1 = reinterpret_cast< wxImage * >(argp1);
14009 ecode2 = SWIG_AsVal_int(obj1, &val2);
14010 if (!SWIG_IsOK(ecode2)) {
14011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14012 }
14013 arg2 = static_cast< int >(val2);
14014 ecode3 = SWIG_AsVal_int(obj2, &val3);
14015 if (!SWIG_IsOK(ecode3)) {
14016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14017 }
14018 arg3 = static_cast< int >(val3);
14019 {
14020 PyThreadState* __tstate = wxPyBeginAllowThreads();
14021 result = (byte)(arg1)->GetBlue(arg2,arg3);
14022 wxPyEndAllowThreads(__tstate);
14023 if (PyErr_Occurred()) SWIG_fail;
14024 }
14025 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14026 return resultobj;
14027 fail:
14028 return NULL;
14029 }
14030
14031
14032 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14033 PyObject *resultobj = 0;
14034 wxImage *arg1 = (wxImage *) 0 ;
14035 int arg2 ;
14036 int arg3 ;
14037 byte arg4 ;
14038 void *argp1 = 0 ;
14039 int res1 = 0 ;
14040 int val2 ;
14041 int ecode2 = 0 ;
14042 int val3 ;
14043 int ecode3 = 0 ;
14044 unsigned char val4 ;
14045 int ecode4 = 0 ;
14046 PyObject * obj0 = 0 ;
14047 PyObject * obj1 = 0 ;
14048 PyObject * obj2 = 0 ;
14049 PyObject * obj3 = 0 ;
14050 char * kwnames[] = {
14051 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14052 };
14053
14054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14056 if (!SWIG_IsOK(res1)) {
14057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14058 }
14059 arg1 = reinterpret_cast< wxImage * >(argp1);
14060 ecode2 = SWIG_AsVal_int(obj1, &val2);
14061 if (!SWIG_IsOK(ecode2)) {
14062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14063 }
14064 arg2 = static_cast< int >(val2);
14065 ecode3 = SWIG_AsVal_int(obj2, &val3);
14066 if (!SWIG_IsOK(ecode3)) {
14067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14068 }
14069 arg3 = static_cast< int >(val3);
14070 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14071 if (!SWIG_IsOK(ecode4)) {
14072 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14073 }
14074 arg4 = static_cast< byte >(val4);
14075 {
14076 PyThreadState* __tstate = wxPyBeginAllowThreads();
14077 (arg1)->SetAlpha(arg2,arg3,arg4);
14078 wxPyEndAllowThreads(__tstate);
14079 if (PyErr_Occurred()) SWIG_fail;
14080 }
14081 resultobj = SWIG_Py_Void();
14082 return resultobj;
14083 fail:
14084 return NULL;
14085 }
14086
14087
14088 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14089 PyObject *resultobj = 0;
14090 wxImage *arg1 = (wxImage *) 0 ;
14091 int arg2 ;
14092 int arg3 ;
14093 byte result;
14094 void *argp1 = 0 ;
14095 int res1 = 0 ;
14096 int val2 ;
14097 int ecode2 = 0 ;
14098 int val3 ;
14099 int ecode3 = 0 ;
14100 PyObject * obj0 = 0 ;
14101 PyObject * obj1 = 0 ;
14102 PyObject * obj2 = 0 ;
14103 char * kwnames[] = {
14104 (char *) "self",(char *) "x",(char *) "y", NULL
14105 };
14106
14107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14109 if (!SWIG_IsOK(res1)) {
14110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14111 }
14112 arg1 = reinterpret_cast< wxImage * >(argp1);
14113 ecode2 = SWIG_AsVal_int(obj1, &val2);
14114 if (!SWIG_IsOK(ecode2)) {
14115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14116 }
14117 arg2 = static_cast< int >(val2);
14118 ecode3 = SWIG_AsVal_int(obj2, &val3);
14119 if (!SWIG_IsOK(ecode3)) {
14120 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14121 }
14122 arg3 = static_cast< int >(val3);
14123 {
14124 PyThreadState* __tstate = wxPyBeginAllowThreads();
14125 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14126 wxPyEndAllowThreads(__tstate);
14127 if (PyErr_Occurred()) SWIG_fail;
14128 }
14129 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14130 return resultobj;
14131 fail:
14132 return NULL;
14133 }
14134
14135
14136 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14137 PyObject *resultobj = 0;
14138 wxImage *arg1 = (wxImage *) 0 ;
14139 bool result;
14140 void *argp1 = 0 ;
14141 int res1 = 0 ;
14142 PyObject *swig_obj[1] ;
14143
14144 if (!args) SWIG_fail;
14145 swig_obj[0] = args;
14146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14147 if (!SWIG_IsOK(res1)) {
14148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14149 }
14150 arg1 = reinterpret_cast< wxImage * >(argp1);
14151 {
14152 PyThreadState* __tstate = wxPyBeginAllowThreads();
14153 result = (bool)(arg1)->HasAlpha();
14154 wxPyEndAllowThreads(__tstate);
14155 if (PyErr_Occurred()) SWIG_fail;
14156 }
14157 {
14158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14159 }
14160 return resultobj;
14161 fail:
14162 return NULL;
14163 }
14164
14165
14166 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14167 PyObject *resultobj = 0;
14168 wxImage *arg1 = (wxImage *) 0 ;
14169 void *argp1 = 0 ;
14170 int res1 = 0 ;
14171 PyObject *swig_obj[1] ;
14172
14173 if (!args) SWIG_fail;
14174 swig_obj[0] = args;
14175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14176 if (!SWIG_IsOK(res1)) {
14177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14178 }
14179 arg1 = reinterpret_cast< wxImage * >(argp1);
14180 {
14181 PyThreadState* __tstate = wxPyBeginAllowThreads();
14182 (arg1)->InitAlpha();
14183 wxPyEndAllowThreads(__tstate);
14184 if (PyErr_Occurred()) SWIG_fail;
14185 }
14186 resultobj = SWIG_Py_Void();
14187 return resultobj;
14188 fail:
14189 return NULL;
14190 }
14191
14192
14193 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14194 PyObject *resultobj = 0;
14195 wxImage *arg1 = (wxImage *) 0 ;
14196 int arg2 ;
14197 int arg3 ;
14198 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14199 bool result;
14200 void *argp1 = 0 ;
14201 int res1 = 0 ;
14202 int val2 ;
14203 int ecode2 = 0 ;
14204 int val3 ;
14205 int ecode3 = 0 ;
14206 unsigned char val4 ;
14207 int ecode4 = 0 ;
14208 PyObject * obj0 = 0 ;
14209 PyObject * obj1 = 0 ;
14210 PyObject * obj2 = 0 ;
14211 PyObject * obj3 = 0 ;
14212 char * kwnames[] = {
14213 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14214 };
14215
14216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14218 if (!SWIG_IsOK(res1)) {
14219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14220 }
14221 arg1 = reinterpret_cast< wxImage * >(argp1);
14222 ecode2 = SWIG_AsVal_int(obj1, &val2);
14223 if (!SWIG_IsOK(ecode2)) {
14224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14225 }
14226 arg2 = static_cast< int >(val2);
14227 ecode3 = SWIG_AsVal_int(obj2, &val3);
14228 if (!SWIG_IsOK(ecode3)) {
14229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14230 }
14231 arg3 = static_cast< int >(val3);
14232 if (obj3) {
14233 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14234 if (!SWIG_IsOK(ecode4)) {
14235 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14236 }
14237 arg4 = static_cast< byte >(val4);
14238 }
14239 {
14240 PyThreadState* __tstate = wxPyBeginAllowThreads();
14241 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14242 wxPyEndAllowThreads(__tstate);
14243 if (PyErr_Occurred()) SWIG_fail;
14244 }
14245 {
14246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14247 }
14248 return resultobj;
14249 fail:
14250 return NULL;
14251 }
14252
14253
14254 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14255 PyObject *resultobj = 0;
14256 wxImage *arg1 = (wxImage *) 0 ;
14257 byte *arg2 = (byte *) 0 ;
14258 byte *arg3 = (byte *) 0 ;
14259 byte *arg4 = (byte *) 0 ;
14260 byte arg5 = (byte) 0 ;
14261 byte arg6 = (byte) 0 ;
14262 byte arg7 = (byte) 0 ;
14263 bool result;
14264 void *argp1 = 0 ;
14265 int res1 = 0 ;
14266 byte temp2 ;
14267 int res2 = SWIG_TMPOBJ ;
14268 byte temp3 ;
14269 int res3 = SWIG_TMPOBJ ;
14270 byte temp4 ;
14271 int res4 = SWIG_TMPOBJ ;
14272 unsigned char val5 ;
14273 int ecode5 = 0 ;
14274 unsigned char val6 ;
14275 int ecode6 = 0 ;
14276 unsigned char val7 ;
14277 int ecode7 = 0 ;
14278 PyObject * obj0 = 0 ;
14279 PyObject * obj1 = 0 ;
14280 PyObject * obj2 = 0 ;
14281 PyObject * obj3 = 0 ;
14282 char * kwnames[] = {
14283 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14284 };
14285
14286 arg2 = &temp2;
14287 arg3 = &temp3;
14288 arg4 = &temp4;
14289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14291 if (!SWIG_IsOK(res1)) {
14292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14293 }
14294 arg1 = reinterpret_cast< wxImage * >(argp1);
14295 if (obj1) {
14296 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14297 if (!SWIG_IsOK(ecode5)) {
14298 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14299 }
14300 arg5 = static_cast< byte >(val5);
14301 }
14302 if (obj2) {
14303 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14304 if (!SWIG_IsOK(ecode6)) {
14305 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14306 }
14307 arg6 = static_cast< byte >(val6);
14308 }
14309 if (obj3) {
14310 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14311 if (!SWIG_IsOK(ecode7)) {
14312 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14313 }
14314 arg7 = static_cast< byte >(val7);
14315 }
14316 {
14317 PyThreadState* __tstate = wxPyBeginAllowThreads();
14318 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14319 wxPyEndAllowThreads(__tstate);
14320 if (PyErr_Occurred()) SWIG_fail;
14321 }
14322 {
14323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14324 }
14325 if (SWIG_IsTmpObj(res2)) {
14326 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14327 } else {
14328 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14329 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14330 }
14331 if (SWIG_IsTmpObj(res3)) {
14332 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14333 } else {
14334 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14335 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14336 }
14337 if (SWIG_IsTmpObj(res4)) {
14338 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14339 } else {
14340 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14341 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14342 }
14343 return resultobj;
14344 fail:
14345 return NULL;
14346 }
14347
14348
14349 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14350 PyObject *resultobj = 0;
14351 wxImage *arg1 = (wxImage *) 0 ;
14352 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14353 bool result;
14354 void *argp1 = 0 ;
14355 int res1 = 0 ;
14356 unsigned char val2 ;
14357 int ecode2 = 0 ;
14358 PyObject * obj0 = 0 ;
14359 PyObject * obj1 = 0 ;
14360 char * kwnames[] = {
14361 (char *) "self",(char *) "threshold", NULL
14362 };
14363
14364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14366 if (!SWIG_IsOK(res1)) {
14367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14368 }
14369 arg1 = reinterpret_cast< wxImage * >(argp1);
14370 if (obj1) {
14371 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14372 if (!SWIG_IsOK(ecode2)) {
14373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14374 }
14375 arg2 = static_cast< byte >(val2);
14376 }
14377 {
14378 PyThreadState* __tstate = wxPyBeginAllowThreads();
14379 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14380 wxPyEndAllowThreads(__tstate);
14381 if (PyErr_Occurred()) SWIG_fail;
14382 }
14383 {
14384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14385 }
14386 return resultobj;
14387 fail:
14388 return NULL;
14389 }
14390
14391
14392 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14393 PyObject *resultobj = 0;
14394 wxImage *arg1 = (wxImage *) 0 ;
14395 byte arg2 ;
14396 byte arg3 ;
14397 byte arg4 ;
14398 bool result;
14399 void *argp1 = 0 ;
14400 int res1 = 0 ;
14401 unsigned char val2 ;
14402 int ecode2 = 0 ;
14403 unsigned char val3 ;
14404 int ecode3 = 0 ;
14405 unsigned char val4 ;
14406 int ecode4 = 0 ;
14407 PyObject * obj0 = 0 ;
14408 PyObject * obj1 = 0 ;
14409 PyObject * obj2 = 0 ;
14410 PyObject * obj3 = 0 ;
14411 char * kwnames[] = {
14412 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14413 };
14414
14415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14417 if (!SWIG_IsOK(res1)) {
14418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14419 }
14420 arg1 = reinterpret_cast< wxImage * >(argp1);
14421 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14422 if (!SWIG_IsOK(ecode2)) {
14423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14424 }
14425 arg2 = static_cast< byte >(val2);
14426 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14427 if (!SWIG_IsOK(ecode3)) {
14428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', 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_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14434 }
14435 arg4 = static_cast< byte >(val4);
14436 {
14437 PyThreadState* __tstate = wxPyBeginAllowThreads();
14438 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14439 wxPyEndAllowThreads(__tstate);
14440 if (PyErr_Occurred()) SWIG_fail;
14441 }
14442 {
14443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14444 }
14445 return resultobj;
14446 fail:
14447 return NULL;
14448 }
14449
14450
14451 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14452 PyObject *resultobj = 0;
14453 wxImage *arg1 = (wxImage *) 0 ;
14454 wxImage *arg2 = 0 ;
14455 byte arg3 ;
14456 byte arg4 ;
14457 byte arg5 ;
14458 bool result;
14459 void *argp1 = 0 ;
14460 int res1 = 0 ;
14461 void *argp2 = 0 ;
14462 int res2 = 0 ;
14463 unsigned char val3 ;
14464 int ecode3 = 0 ;
14465 unsigned char val4 ;
14466 int ecode4 = 0 ;
14467 unsigned char val5 ;
14468 int ecode5 = 0 ;
14469 PyObject * obj0 = 0 ;
14470 PyObject * obj1 = 0 ;
14471 PyObject * obj2 = 0 ;
14472 PyObject * obj3 = 0 ;
14473 PyObject * obj4 = 0 ;
14474 char * kwnames[] = {
14475 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14476 };
14477
14478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14480 if (!SWIG_IsOK(res1)) {
14481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14482 }
14483 arg1 = reinterpret_cast< wxImage * >(argp1);
14484 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14485 if (!SWIG_IsOK(res2)) {
14486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14487 }
14488 if (!argp2) {
14489 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14490 }
14491 arg2 = reinterpret_cast< wxImage * >(argp2);
14492 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14493 if (!SWIG_IsOK(ecode3)) {
14494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14495 }
14496 arg3 = static_cast< byte >(val3);
14497 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14498 if (!SWIG_IsOK(ecode4)) {
14499 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14500 }
14501 arg4 = static_cast< byte >(val4);
14502 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14503 if (!SWIG_IsOK(ecode5)) {
14504 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14505 }
14506 arg5 = static_cast< byte >(val5);
14507 {
14508 PyThreadState* __tstate = wxPyBeginAllowThreads();
14509 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14510 wxPyEndAllowThreads(__tstate);
14511 if (PyErr_Occurred()) SWIG_fail;
14512 }
14513 {
14514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14515 }
14516 return resultobj;
14517 fail:
14518 return NULL;
14519 }
14520
14521
14522 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14523 PyObject *resultobj = 0;
14524 wxString *arg1 = 0 ;
14525 bool result;
14526 bool temp1 = false ;
14527 PyObject * obj0 = 0 ;
14528 char * kwnames[] = {
14529 (char *) "filename", NULL
14530 };
14531
14532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14533 {
14534 arg1 = wxString_in_helper(obj0);
14535 if (arg1 == NULL) SWIG_fail;
14536 temp1 = true;
14537 }
14538 {
14539 PyThreadState* __tstate = wxPyBeginAllowThreads();
14540 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14541 wxPyEndAllowThreads(__tstate);
14542 if (PyErr_Occurred()) SWIG_fail;
14543 }
14544 {
14545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14546 }
14547 {
14548 if (temp1)
14549 delete arg1;
14550 }
14551 return resultobj;
14552 fail:
14553 {
14554 if (temp1)
14555 delete arg1;
14556 }
14557 return NULL;
14558 }
14559
14560
14561 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14562 PyObject *resultobj = 0;
14563 wxString *arg1 = 0 ;
14564 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14565 int result;
14566 bool temp1 = false ;
14567 long val2 ;
14568 int ecode2 = 0 ;
14569 PyObject * obj0 = 0 ;
14570 PyObject * obj1 = 0 ;
14571 char * kwnames[] = {
14572 (char *) "filename",(char *) "type", NULL
14573 };
14574
14575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14576 {
14577 arg1 = wxString_in_helper(obj0);
14578 if (arg1 == NULL) SWIG_fail;
14579 temp1 = true;
14580 }
14581 if (obj1) {
14582 ecode2 = SWIG_AsVal_long(obj1, &val2);
14583 if (!SWIG_IsOK(ecode2)) {
14584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14585 }
14586 arg2 = static_cast< long >(val2);
14587 }
14588 {
14589 PyThreadState* __tstate = wxPyBeginAllowThreads();
14590 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14591 wxPyEndAllowThreads(__tstate);
14592 if (PyErr_Occurred()) SWIG_fail;
14593 }
14594 resultobj = SWIG_From_int(static_cast< int >(result));
14595 {
14596 if (temp1)
14597 delete arg1;
14598 }
14599 return resultobj;
14600 fail:
14601 {
14602 if (temp1)
14603 delete arg1;
14604 }
14605 return NULL;
14606 }
14607
14608
14609 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14610 PyObject *resultobj = 0;
14611 wxImage *arg1 = (wxImage *) 0 ;
14612 wxString *arg2 = 0 ;
14613 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14614 int arg4 = (int) -1 ;
14615 bool result;
14616 void *argp1 = 0 ;
14617 int res1 = 0 ;
14618 bool temp2 = false ;
14619 long val3 ;
14620 int ecode3 = 0 ;
14621 int val4 ;
14622 int ecode4 = 0 ;
14623 PyObject * obj0 = 0 ;
14624 PyObject * obj1 = 0 ;
14625 PyObject * obj2 = 0 ;
14626 PyObject * obj3 = 0 ;
14627 char * kwnames[] = {
14628 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14629 };
14630
14631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14633 if (!SWIG_IsOK(res1)) {
14634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14635 }
14636 arg1 = reinterpret_cast< wxImage * >(argp1);
14637 {
14638 arg2 = wxString_in_helper(obj1);
14639 if (arg2 == NULL) SWIG_fail;
14640 temp2 = true;
14641 }
14642 if (obj2) {
14643 ecode3 = SWIG_AsVal_long(obj2, &val3);
14644 if (!SWIG_IsOK(ecode3)) {
14645 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14646 }
14647 arg3 = static_cast< long >(val3);
14648 }
14649 if (obj3) {
14650 ecode4 = SWIG_AsVal_int(obj3, &val4);
14651 if (!SWIG_IsOK(ecode4)) {
14652 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14653 }
14654 arg4 = static_cast< int >(val4);
14655 }
14656 {
14657 PyThreadState* __tstate = wxPyBeginAllowThreads();
14658 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14659 wxPyEndAllowThreads(__tstate);
14660 if (PyErr_Occurred()) SWIG_fail;
14661 }
14662 {
14663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14664 }
14665 {
14666 if (temp2)
14667 delete arg2;
14668 }
14669 return resultobj;
14670 fail:
14671 {
14672 if (temp2)
14673 delete arg2;
14674 }
14675 return NULL;
14676 }
14677
14678
14679 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14680 PyObject *resultobj = 0;
14681 wxImage *arg1 = (wxImage *) 0 ;
14682 wxString *arg2 = 0 ;
14683 wxString *arg3 = 0 ;
14684 int arg4 = (int) -1 ;
14685 bool result;
14686 void *argp1 = 0 ;
14687 int res1 = 0 ;
14688 bool temp2 = false ;
14689 bool temp3 = false ;
14690 int val4 ;
14691 int ecode4 = 0 ;
14692 PyObject * obj0 = 0 ;
14693 PyObject * obj1 = 0 ;
14694 PyObject * obj2 = 0 ;
14695 PyObject * obj3 = 0 ;
14696 char * kwnames[] = {
14697 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14698 };
14699
14700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14702 if (!SWIG_IsOK(res1)) {
14703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14704 }
14705 arg1 = reinterpret_cast< wxImage * >(argp1);
14706 {
14707 arg2 = wxString_in_helper(obj1);
14708 if (arg2 == NULL) SWIG_fail;
14709 temp2 = true;
14710 }
14711 {
14712 arg3 = wxString_in_helper(obj2);
14713 if (arg3 == NULL) SWIG_fail;
14714 temp3 = true;
14715 }
14716 if (obj3) {
14717 ecode4 = SWIG_AsVal_int(obj3, &val4);
14718 if (!SWIG_IsOK(ecode4)) {
14719 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14720 }
14721 arg4 = static_cast< int >(val4);
14722 }
14723 {
14724 PyThreadState* __tstate = wxPyBeginAllowThreads();
14725 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14726 wxPyEndAllowThreads(__tstate);
14727 if (PyErr_Occurred()) SWIG_fail;
14728 }
14729 {
14730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14731 }
14732 {
14733 if (temp2)
14734 delete arg2;
14735 }
14736 {
14737 if (temp3)
14738 delete arg3;
14739 }
14740 return resultobj;
14741 fail:
14742 {
14743 if (temp2)
14744 delete arg2;
14745 }
14746 {
14747 if (temp3)
14748 delete arg3;
14749 }
14750 return NULL;
14751 }
14752
14753
14754 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14755 PyObject *resultobj = 0;
14756 wxImage *arg1 = (wxImage *) 0 ;
14757 wxString *arg2 = 0 ;
14758 int arg3 ;
14759 bool result;
14760 void *argp1 = 0 ;
14761 int res1 = 0 ;
14762 bool temp2 = false ;
14763 int val3 ;
14764 int ecode3 = 0 ;
14765 PyObject * obj0 = 0 ;
14766 PyObject * obj1 = 0 ;
14767 PyObject * obj2 = 0 ;
14768 char * kwnames[] = {
14769 (char *) "self",(char *) "name",(char *) "type", NULL
14770 };
14771
14772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14774 if (!SWIG_IsOK(res1)) {
14775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14776 }
14777 arg1 = reinterpret_cast< wxImage * >(argp1);
14778 {
14779 arg2 = wxString_in_helper(obj1);
14780 if (arg2 == NULL) SWIG_fail;
14781 temp2 = true;
14782 }
14783 ecode3 = SWIG_AsVal_int(obj2, &val3);
14784 if (!SWIG_IsOK(ecode3)) {
14785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14786 }
14787 arg3 = static_cast< int >(val3);
14788 {
14789 PyThreadState* __tstate = wxPyBeginAllowThreads();
14790 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14791 wxPyEndAllowThreads(__tstate);
14792 if (PyErr_Occurred()) SWIG_fail;
14793 }
14794 {
14795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14796 }
14797 {
14798 if (temp2)
14799 delete arg2;
14800 }
14801 return resultobj;
14802 fail:
14803 {
14804 if (temp2)
14805 delete arg2;
14806 }
14807 return NULL;
14808 }
14809
14810
14811 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14812 PyObject *resultobj = 0;
14813 wxImage *arg1 = (wxImage *) 0 ;
14814 wxString *arg2 = 0 ;
14815 wxString *arg3 = 0 ;
14816 bool result;
14817 void *argp1 = 0 ;
14818 int res1 = 0 ;
14819 bool temp2 = false ;
14820 bool temp3 = false ;
14821 PyObject * obj0 = 0 ;
14822 PyObject * obj1 = 0 ;
14823 PyObject * obj2 = 0 ;
14824 char * kwnames[] = {
14825 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14826 };
14827
14828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14830 if (!SWIG_IsOK(res1)) {
14831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14832 }
14833 arg1 = reinterpret_cast< wxImage * >(argp1);
14834 {
14835 arg2 = wxString_in_helper(obj1);
14836 if (arg2 == NULL) SWIG_fail;
14837 temp2 = true;
14838 }
14839 {
14840 arg3 = wxString_in_helper(obj2);
14841 if (arg3 == NULL) SWIG_fail;
14842 temp3 = true;
14843 }
14844 {
14845 PyThreadState* __tstate = wxPyBeginAllowThreads();
14846 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14847 wxPyEndAllowThreads(__tstate);
14848 if (PyErr_Occurred()) SWIG_fail;
14849 }
14850 {
14851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14852 }
14853 {
14854 if (temp2)
14855 delete arg2;
14856 }
14857 {
14858 if (temp3)
14859 delete arg3;
14860 }
14861 return resultobj;
14862 fail:
14863 {
14864 if (temp2)
14865 delete arg2;
14866 }
14867 {
14868 if (temp3)
14869 delete arg3;
14870 }
14871 return NULL;
14872 }
14873
14874
14875 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14876 PyObject *resultobj = 0;
14877 wxInputStream *arg1 = 0 ;
14878 bool result;
14879 wxPyInputStream *temp1 ;
14880 bool created1 ;
14881 PyObject * obj0 = 0 ;
14882 char * kwnames[] = {
14883 (char *) "stream", NULL
14884 };
14885
14886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14887 {
14888 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14889 arg1 = temp1->m_wxis;
14890 created1 = false;
14891 } else {
14892 PyErr_Clear(); // clear the failure of the wxPyConvert above
14893 arg1 = wxPyCBInputStream_create(obj0, false);
14894 if (arg1 == NULL) {
14895 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14896 SWIG_fail;
14897 }
14898 created1 = true;
14899 }
14900 }
14901 {
14902 PyThreadState* __tstate = wxPyBeginAllowThreads();
14903 result = (bool)wxImage::CanRead(*arg1);
14904 wxPyEndAllowThreads(__tstate);
14905 if (PyErr_Occurred()) SWIG_fail;
14906 }
14907 {
14908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14909 }
14910 {
14911 if (created1) delete arg1;
14912 }
14913 return resultobj;
14914 fail:
14915 {
14916 if (created1) delete arg1;
14917 }
14918 return NULL;
14919 }
14920
14921
14922 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14923 PyObject *resultobj = 0;
14924 wxImage *arg1 = (wxImage *) 0 ;
14925 wxInputStream *arg2 = 0 ;
14926 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14927 int arg4 = (int) -1 ;
14928 bool result;
14929 void *argp1 = 0 ;
14930 int res1 = 0 ;
14931 wxPyInputStream *temp2 ;
14932 bool created2 ;
14933 long val3 ;
14934 int ecode3 = 0 ;
14935 int val4 ;
14936 int ecode4 = 0 ;
14937 PyObject * obj0 = 0 ;
14938 PyObject * obj1 = 0 ;
14939 PyObject * obj2 = 0 ;
14940 PyObject * obj3 = 0 ;
14941 char * kwnames[] = {
14942 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14943 };
14944
14945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14947 if (!SWIG_IsOK(res1)) {
14948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14949 }
14950 arg1 = reinterpret_cast< wxImage * >(argp1);
14951 {
14952 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14953 arg2 = temp2->m_wxis;
14954 created2 = false;
14955 } else {
14956 PyErr_Clear(); // clear the failure of the wxPyConvert above
14957 arg2 = wxPyCBInputStream_create(obj1, false);
14958 if (arg2 == NULL) {
14959 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14960 SWIG_fail;
14961 }
14962 created2 = true;
14963 }
14964 }
14965 if (obj2) {
14966 ecode3 = SWIG_AsVal_long(obj2, &val3);
14967 if (!SWIG_IsOK(ecode3)) {
14968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14969 }
14970 arg3 = static_cast< long >(val3);
14971 }
14972 if (obj3) {
14973 ecode4 = SWIG_AsVal_int(obj3, &val4);
14974 if (!SWIG_IsOK(ecode4)) {
14975 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14976 }
14977 arg4 = static_cast< int >(val4);
14978 }
14979 {
14980 PyThreadState* __tstate = wxPyBeginAllowThreads();
14981 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14982 wxPyEndAllowThreads(__tstate);
14983 if (PyErr_Occurred()) SWIG_fail;
14984 }
14985 {
14986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14987 }
14988 {
14989 if (created2) delete arg2;
14990 }
14991 return resultobj;
14992 fail:
14993 {
14994 if (created2) delete arg2;
14995 }
14996 return NULL;
14997 }
14998
14999
15000 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15001 PyObject *resultobj = 0;
15002 wxImage *arg1 = (wxImage *) 0 ;
15003 wxInputStream *arg2 = 0 ;
15004 wxString *arg3 = 0 ;
15005 int arg4 = (int) -1 ;
15006 bool result;
15007 void *argp1 = 0 ;
15008 int res1 = 0 ;
15009 wxPyInputStream *temp2 ;
15010 bool created2 ;
15011 bool temp3 = false ;
15012 int val4 ;
15013 int ecode4 = 0 ;
15014 PyObject * obj0 = 0 ;
15015 PyObject * obj1 = 0 ;
15016 PyObject * obj2 = 0 ;
15017 PyObject * obj3 = 0 ;
15018 char * kwnames[] = {
15019 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15020 };
15021
15022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15024 if (!SWIG_IsOK(res1)) {
15025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15026 }
15027 arg1 = reinterpret_cast< wxImage * >(argp1);
15028 {
15029 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15030 arg2 = temp2->m_wxis;
15031 created2 = false;
15032 } else {
15033 PyErr_Clear(); // clear the failure of the wxPyConvert above
15034 arg2 = wxPyCBInputStream_create(obj1, false);
15035 if (arg2 == NULL) {
15036 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15037 SWIG_fail;
15038 }
15039 created2 = true;
15040 }
15041 }
15042 {
15043 arg3 = wxString_in_helper(obj2);
15044 if (arg3 == NULL) SWIG_fail;
15045 temp3 = true;
15046 }
15047 if (obj3) {
15048 ecode4 = SWIG_AsVal_int(obj3, &val4);
15049 if (!SWIG_IsOK(ecode4)) {
15050 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15051 }
15052 arg4 = static_cast< int >(val4);
15053 }
15054 {
15055 PyThreadState* __tstate = wxPyBeginAllowThreads();
15056 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15057 wxPyEndAllowThreads(__tstate);
15058 if (PyErr_Occurred()) SWIG_fail;
15059 }
15060 {
15061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15062 }
15063 {
15064 if (created2) delete arg2;
15065 }
15066 {
15067 if (temp3)
15068 delete arg3;
15069 }
15070 return resultobj;
15071 fail:
15072 {
15073 if (created2) delete arg2;
15074 }
15075 {
15076 if (temp3)
15077 delete arg3;
15078 }
15079 return NULL;
15080 }
15081
15082
15083 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15084 PyObject *resultobj = 0;
15085 wxImage *arg1 = (wxImage *) 0 ;
15086 bool result;
15087 void *argp1 = 0 ;
15088 int res1 = 0 ;
15089 PyObject *swig_obj[1] ;
15090
15091 if (!args) SWIG_fail;
15092 swig_obj[0] = args;
15093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15094 if (!SWIG_IsOK(res1)) {
15095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15096 }
15097 arg1 = reinterpret_cast< wxImage * >(argp1);
15098 {
15099 PyThreadState* __tstate = wxPyBeginAllowThreads();
15100 result = (bool)(arg1)->Ok();
15101 wxPyEndAllowThreads(__tstate);
15102 if (PyErr_Occurred()) SWIG_fail;
15103 }
15104 {
15105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15106 }
15107 return resultobj;
15108 fail:
15109 return NULL;
15110 }
15111
15112
15113 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15114 PyObject *resultobj = 0;
15115 wxImage *arg1 = (wxImage *) 0 ;
15116 int result;
15117 void *argp1 = 0 ;
15118 int res1 = 0 ;
15119 PyObject *swig_obj[1] ;
15120
15121 if (!args) SWIG_fail;
15122 swig_obj[0] = args;
15123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15124 if (!SWIG_IsOK(res1)) {
15125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15126 }
15127 arg1 = reinterpret_cast< wxImage * >(argp1);
15128 {
15129 PyThreadState* __tstate = wxPyBeginAllowThreads();
15130 result = (int)(arg1)->GetWidth();
15131 wxPyEndAllowThreads(__tstate);
15132 if (PyErr_Occurred()) SWIG_fail;
15133 }
15134 resultobj = SWIG_From_int(static_cast< int >(result));
15135 return resultobj;
15136 fail:
15137 return NULL;
15138 }
15139
15140
15141 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15142 PyObject *resultobj = 0;
15143 wxImage *arg1 = (wxImage *) 0 ;
15144 int result;
15145 void *argp1 = 0 ;
15146 int res1 = 0 ;
15147 PyObject *swig_obj[1] ;
15148
15149 if (!args) SWIG_fail;
15150 swig_obj[0] = args;
15151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15152 if (!SWIG_IsOK(res1)) {
15153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15154 }
15155 arg1 = reinterpret_cast< wxImage * >(argp1);
15156 {
15157 PyThreadState* __tstate = wxPyBeginAllowThreads();
15158 result = (int)(arg1)->GetHeight();
15159 wxPyEndAllowThreads(__tstate);
15160 if (PyErr_Occurred()) SWIG_fail;
15161 }
15162 resultobj = SWIG_From_int(static_cast< int >(result));
15163 return resultobj;
15164 fail:
15165 return NULL;
15166 }
15167
15168
15169 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15170 PyObject *resultobj = 0;
15171 wxImage *arg1 = (wxImage *) 0 ;
15172 wxSize result;
15173 void *argp1 = 0 ;
15174 int res1 = 0 ;
15175 PyObject *swig_obj[1] ;
15176
15177 if (!args) SWIG_fail;
15178 swig_obj[0] = args;
15179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15180 if (!SWIG_IsOK(res1)) {
15181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15182 }
15183 arg1 = reinterpret_cast< wxImage * >(argp1);
15184 {
15185 PyThreadState* __tstate = wxPyBeginAllowThreads();
15186 result = wxImage_GetSize(arg1);
15187 wxPyEndAllowThreads(__tstate);
15188 if (PyErr_Occurred()) SWIG_fail;
15189 }
15190 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15191 return resultobj;
15192 fail:
15193 return NULL;
15194 }
15195
15196
15197 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15198 PyObject *resultobj = 0;
15199 wxImage *arg1 = (wxImage *) 0 ;
15200 wxRect *arg2 = 0 ;
15201 SwigValueWrapper<wxImage > result;
15202 void *argp1 = 0 ;
15203 int res1 = 0 ;
15204 wxRect temp2 ;
15205 PyObject * obj0 = 0 ;
15206 PyObject * obj1 = 0 ;
15207 char * kwnames[] = {
15208 (char *) "self",(char *) "rect", NULL
15209 };
15210
15211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15213 if (!SWIG_IsOK(res1)) {
15214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15215 }
15216 arg1 = reinterpret_cast< wxImage * >(argp1);
15217 {
15218 arg2 = &temp2;
15219 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15220 }
15221 {
15222 PyThreadState* __tstate = wxPyBeginAllowThreads();
15223 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15224 wxPyEndAllowThreads(__tstate);
15225 if (PyErr_Occurred()) SWIG_fail;
15226 }
15227 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15228 return resultobj;
15229 fail:
15230 return NULL;
15231 }
15232
15233
15234 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15235 PyObject *resultobj = 0;
15236 wxImage *arg1 = (wxImage *) 0 ;
15237 wxSize *arg2 = 0 ;
15238 wxPoint *arg3 = 0 ;
15239 int arg4 = (int) -1 ;
15240 int arg5 = (int) -1 ;
15241 int arg6 = (int) -1 ;
15242 SwigValueWrapper<wxImage > result;
15243 void *argp1 = 0 ;
15244 int res1 = 0 ;
15245 wxSize temp2 ;
15246 wxPoint temp3 ;
15247 int val4 ;
15248 int ecode4 = 0 ;
15249 int val5 ;
15250 int ecode5 = 0 ;
15251 int val6 ;
15252 int ecode6 = 0 ;
15253 PyObject * obj0 = 0 ;
15254 PyObject * obj1 = 0 ;
15255 PyObject * obj2 = 0 ;
15256 PyObject * obj3 = 0 ;
15257 PyObject * obj4 = 0 ;
15258 PyObject * obj5 = 0 ;
15259 char * kwnames[] = {
15260 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15261 };
15262
15263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15265 if (!SWIG_IsOK(res1)) {
15266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15267 }
15268 arg1 = reinterpret_cast< wxImage * >(argp1);
15269 {
15270 arg2 = &temp2;
15271 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15272 }
15273 {
15274 arg3 = &temp3;
15275 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15276 }
15277 if (obj3) {
15278 ecode4 = SWIG_AsVal_int(obj3, &val4);
15279 if (!SWIG_IsOK(ecode4)) {
15280 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15281 }
15282 arg4 = static_cast< int >(val4);
15283 }
15284 if (obj4) {
15285 ecode5 = SWIG_AsVal_int(obj4, &val5);
15286 if (!SWIG_IsOK(ecode5)) {
15287 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15288 }
15289 arg5 = static_cast< int >(val5);
15290 }
15291 if (obj5) {
15292 ecode6 = SWIG_AsVal_int(obj5, &val6);
15293 if (!SWIG_IsOK(ecode6)) {
15294 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15295 }
15296 arg6 = static_cast< int >(val6);
15297 }
15298 {
15299 PyThreadState* __tstate = wxPyBeginAllowThreads();
15300 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15301 wxPyEndAllowThreads(__tstate);
15302 if (PyErr_Occurred()) SWIG_fail;
15303 }
15304 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15305 return resultobj;
15306 fail:
15307 return NULL;
15308 }
15309
15310
15311 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15312 PyObject *resultobj = 0;
15313 wxImage *arg1 = (wxImage *) 0 ;
15314 SwigValueWrapper<wxImage > result;
15315 void *argp1 = 0 ;
15316 int res1 = 0 ;
15317 PyObject *swig_obj[1] ;
15318
15319 if (!args) SWIG_fail;
15320 swig_obj[0] = args;
15321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15322 if (!SWIG_IsOK(res1)) {
15323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15324 }
15325 arg1 = reinterpret_cast< wxImage * >(argp1);
15326 {
15327 PyThreadState* __tstate = wxPyBeginAllowThreads();
15328 result = (arg1)->Copy();
15329 wxPyEndAllowThreads(__tstate);
15330 if (PyErr_Occurred()) SWIG_fail;
15331 }
15332 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15333 return resultobj;
15334 fail:
15335 return NULL;
15336 }
15337
15338
15339 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15340 PyObject *resultobj = 0;
15341 wxImage *arg1 = (wxImage *) 0 ;
15342 wxImage *arg2 = 0 ;
15343 int arg3 ;
15344 int arg4 ;
15345 void *argp1 = 0 ;
15346 int res1 = 0 ;
15347 void *argp2 = 0 ;
15348 int res2 = 0 ;
15349 int val3 ;
15350 int ecode3 = 0 ;
15351 int val4 ;
15352 int ecode4 = 0 ;
15353 PyObject * obj0 = 0 ;
15354 PyObject * obj1 = 0 ;
15355 PyObject * obj2 = 0 ;
15356 PyObject * obj3 = 0 ;
15357 char * kwnames[] = {
15358 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15359 };
15360
15361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15363 if (!SWIG_IsOK(res1)) {
15364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15365 }
15366 arg1 = reinterpret_cast< wxImage * >(argp1);
15367 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15368 if (!SWIG_IsOK(res2)) {
15369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15370 }
15371 if (!argp2) {
15372 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15373 }
15374 arg2 = reinterpret_cast< wxImage * >(argp2);
15375 ecode3 = SWIG_AsVal_int(obj2, &val3);
15376 if (!SWIG_IsOK(ecode3)) {
15377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15378 }
15379 arg3 = static_cast< int >(val3);
15380 ecode4 = SWIG_AsVal_int(obj3, &val4);
15381 if (!SWIG_IsOK(ecode4)) {
15382 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15383 }
15384 arg4 = static_cast< int >(val4);
15385 {
15386 PyThreadState* __tstate = wxPyBeginAllowThreads();
15387 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15388 wxPyEndAllowThreads(__tstate);
15389 if (PyErr_Occurred()) SWIG_fail;
15390 }
15391 resultobj = SWIG_Py_Void();
15392 return resultobj;
15393 fail:
15394 return NULL;
15395 }
15396
15397
15398 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15399 PyObject *resultobj = 0;
15400 wxImage *arg1 = (wxImage *) 0 ;
15401 PyObject *result = 0 ;
15402 void *argp1 = 0 ;
15403 int res1 = 0 ;
15404 PyObject *swig_obj[1] ;
15405
15406 if (!args) SWIG_fail;
15407 swig_obj[0] = args;
15408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15409 if (!SWIG_IsOK(res1)) {
15410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15411 }
15412 arg1 = reinterpret_cast< wxImage * >(argp1);
15413 {
15414 PyThreadState* __tstate = wxPyBeginAllowThreads();
15415 result = (PyObject *)wxImage_GetData(arg1);
15416 wxPyEndAllowThreads(__tstate);
15417 if (PyErr_Occurred()) SWIG_fail;
15418 }
15419 resultobj = result;
15420 return resultobj;
15421 fail:
15422 return NULL;
15423 }
15424
15425
15426 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15427 PyObject *resultobj = 0;
15428 wxImage *arg1 = (wxImage *) 0 ;
15429 buffer arg2 ;
15430 int arg3 ;
15431 void *argp1 = 0 ;
15432 int res1 = 0 ;
15433 PyObject * obj0 = 0 ;
15434 PyObject * obj1 = 0 ;
15435 char * kwnames[] = {
15436 (char *) "self",(char *) "data", NULL
15437 };
15438
15439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15441 if (!SWIG_IsOK(res1)) {
15442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15443 }
15444 arg1 = reinterpret_cast< wxImage * >(argp1);
15445 {
15446 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15447 }
15448 {
15449 PyThreadState* __tstate = wxPyBeginAllowThreads();
15450 wxImage_SetData(arg1,arg2,arg3);
15451 wxPyEndAllowThreads(__tstate);
15452 if (PyErr_Occurred()) SWIG_fail;
15453 }
15454 resultobj = SWIG_Py_Void();
15455 return resultobj;
15456 fail:
15457 return NULL;
15458 }
15459
15460
15461 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15462 PyObject *resultobj = 0;
15463 wxImage *arg1 = (wxImage *) 0 ;
15464 PyObject *result = 0 ;
15465 void *argp1 = 0 ;
15466 int res1 = 0 ;
15467 PyObject *swig_obj[1] ;
15468
15469 if (!args) SWIG_fail;
15470 swig_obj[0] = args;
15471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15472 if (!SWIG_IsOK(res1)) {
15473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15474 }
15475 arg1 = reinterpret_cast< wxImage * >(argp1);
15476 {
15477 PyThreadState* __tstate = wxPyBeginAllowThreads();
15478 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15479 wxPyEndAllowThreads(__tstate);
15480 if (PyErr_Occurred()) SWIG_fail;
15481 }
15482 resultobj = result;
15483 return resultobj;
15484 fail:
15485 return NULL;
15486 }
15487
15488
15489 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15490 PyObject *resultobj = 0;
15491 wxImage *arg1 = (wxImage *) 0 ;
15492 buffer arg2 ;
15493 int arg3 ;
15494 void *argp1 = 0 ;
15495 int res1 = 0 ;
15496 PyObject * obj0 = 0 ;
15497 PyObject * obj1 = 0 ;
15498 char * kwnames[] = {
15499 (char *) "self",(char *) "data", NULL
15500 };
15501
15502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15504 if (!SWIG_IsOK(res1)) {
15505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15506 }
15507 arg1 = reinterpret_cast< wxImage * >(argp1);
15508 {
15509 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15510 }
15511 {
15512 PyThreadState* __tstate = wxPyBeginAllowThreads();
15513 wxImage_SetDataBuffer(arg1,arg2,arg3);
15514 wxPyEndAllowThreads(__tstate);
15515 if (PyErr_Occurred()) SWIG_fail;
15516 }
15517 resultobj = SWIG_Py_Void();
15518 return resultobj;
15519 fail:
15520 return NULL;
15521 }
15522
15523
15524 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15525 PyObject *resultobj = 0;
15526 wxImage *arg1 = (wxImage *) 0 ;
15527 PyObject *result = 0 ;
15528 void *argp1 = 0 ;
15529 int res1 = 0 ;
15530 PyObject *swig_obj[1] ;
15531
15532 if (!args) SWIG_fail;
15533 swig_obj[0] = args;
15534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15535 if (!SWIG_IsOK(res1)) {
15536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15537 }
15538 arg1 = reinterpret_cast< wxImage * >(argp1);
15539 {
15540 PyThreadState* __tstate = wxPyBeginAllowThreads();
15541 result = (PyObject *)wxImage_GetAlphaData(arg1);
15542 wxPyEndAllowThreads(__tstate);
15543 if (PyErr_Occurred()) SWIG_fail;
15544 }
15545 resultobj = result;
15546 return resultobj;
15547 fail:
15548 return NULL;
15549 }
15550
15551
15552 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15553 PyObject *resultobj = 0;
15554 wxImage *arg1 = (wxImage *) 0 ;
15555 buffer arg2 ;
15556 int arg3 ;
15557 void *argp1 = 0 ;
15558 int res1 = 0 ;
15559 PyObject * obj0 = 0 ;
15560 PyObject * obj1 = 0 ;
15561 char * kwnames[] = {
15562 (char *) "self",(char *) "alpha", NULL
15563 };
15564
15565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15567 if (!SWIG_IsOK(res1)) {
15568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15569 }
15570 arg1 = reinterpret_cast< wxImage * >(argp1);
15571 {
15572 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15573 }
15574 {
15575 PyThreadState* __tstate = wxPyBeginAllowThreads();
15576 wxImage_SetAlphaData(arg1,arg2,arg3);
15577 wxPyEndAllowThreads(__tstate);
15578 if (PyErr_Occurred()) SWIG_fail;
15579 }
15580 resultobj = SWIG_Py_Void();
15581 return resultobj;
15582 fail:
15583 return NULL;
15584 }
15585
15586
15587 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15588 PyObject *resultobj = 0;
15589 wxImage *arg1 = (wxImage *) 0 ;
15590 PyObject *result = 0 ;
15591 void *argp1 = 0 ;
15592 int res1 = 0 ;
15593 PyObject *swig_obj[1] ;
15594
15595 if (!args) SWIG_fail;
15596 swig_obj[0] = args;
15597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15598 if (!SWIG_IsOK(res1)) {
15599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15600 }
15601 arg1 = reinterpret_cast< wxImage * >(argp1);
15602 {
15603 PyThreadState* __tstate = wxPyBeginAllowThreads();
15604 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15605 wxPyEndAllowThreads(__tstate);
15606 if (PyErr_Occurred()) SWIG_fail;
15607 }
15608 resultobj = result;
15609 return resultobj;
15610 fail:
15611 return NULL;
15612 }
15613
15614
15615 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15616 PyObject *resultobj = 0;
15617 wxImage *arg1 = (wxImage *) 0 ;
15618 buffer arg2 ;
15619 int arg3 ;
15620 void *argp1 = 0 ;
15621 int res1 = 0 ;
15622 PyObject * obj0 = 0 ;
15623 PyObject * obj1 = 0 ;
15624 char * kwnames[] = {
15625 (char *) "self",(char *) "alpha", NULL
15626 };
15627
15628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15630 if (!SWIG_IsOK(res1)) {
15631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15632 }
15633 arg1 = reinterpret_cast< wxImage * >(argp1);
15634 {
15635 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15636 }
15637 {
15638 PyThreadState* __tstate = wxPyBeginAllowThreads();
15639 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15640 wxPyEndAllowThreads(__tstate);
15641 if (PyErr_Occurred()) SWIG_fail;
15642 }
15643 resultobj = SWIG_Py_Void();
15644 return resultobj;
15645 fail:
15646 return NULL;
15647 }
15648
15649
15650 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15651 PyObject *resultobj = 0;
15652 wxImage *arg1 = (wxImage *) 0 ;
15653 byte arg2 ;
15654 byte arg3 ;
15655 byte arg4 ;
15656 void *argp1 = 0 ;
15657 int res1 = 0 ;
15658 unsigned char val2 ;
15659 int ecode2 = 0 ;
15660 unsigned char val3 ;
15661 int ecode3 = 0 ;
15662 unsigned char val4 ;
15663 int ecode4 = 0 ;
15664 PyObject * obj0 = 0 ;
15665 PyObject * obj1 = 0 ;
15666 PyObject * obj2 = 0 ;
15667 PyObject * obj3 = 0 ;
15668 char * kwnames[] = {
15669 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15670 };
15671
15672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15674 if (!SWIG_IsOK(res1)) {
15675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15676 }
15677 arg1 = reinterpret_cast< wxImage * >(argp1);
15678 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15679 if (!SWIG_IsOK(ecode2)) {
15680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15681 }
15682 arg2 = static_cast< byte >(val2);
15683 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15684 if (!SWIG_IsOK(ecode3)) {
15685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15686 }
15687 arg3 = static_cast< byte >(val3);
15688 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15689 if (!SWIG_IsOK(ecode4)) {
15690 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15691 }
15692 arg4 = static_cast< byte >(val4);
15693 {
15694 PyThreadState* __tstate = wxPyBeginAllowThreads();
15695 (arg1)->SetMaskColour(arg2,arg3,arg4);
15696 wxPyEndAllowThreads(__tstate);
15697 if (PyErr_Occurred()) SWIG_fail;
15698 }
15699 resultobj = SWIG_Py_Void();
15700 return resultobj;
15701 fail:
15702 return NULL;
15703 }
15704
15705
15706 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15707 PyObject *resultobj = 0;
15708 wxImage *arg1 = (wxImage *) 0 ;
15709 byte *arg2 = (byte *) 0 ;
15710 byte *arg3 = (byte *) 0 ;
15711 byte *arg4 = (byte *) 0 ;
15712 void *argp1 = 0 ;
15713 int res1 = 0 ;
15714 byte temp2 ;
15715 int res2 = SWIG_TMPOBJ ;
15716 byte temp3 ;
15717 int res3 = SWIG_TMPOBJ ;
15718 byte temp4 ;
15719 int res4 = SWIG_TMPOBJ ;
15720 PyObject *swig_obj[1] ;
15721
15722 arg2 = &temp2;
15723 arg3 = &temp3;
15724 arg4 = &temp4;
15725 if (!args) SWIG_fail;
15726 swig_obj[0] = args;
15727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15728 if (!SWIG_IsOK(res1)) {
15729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15730 }
15731 arg1 = reinterpret_cast< wxImage * >(argp1);
15732 {
15733 PyThreadState* __tstate = wxPyBeginAllowThreads();
15734 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15735 wxPyEndAllowThreads(__tstate);
15736 if (PyErr_Occurred()) SWIG_fail;
15737 }
15738 resultobj = SWIG_Py_Void();
15739 if (SWIG_IsTmpObj(res2)) {
15740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15741 } else {
15742 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15743 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15744 }
15745 if (SWIG_IsTmpObj(res3)) {
15746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15747 } else {
15748 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15750 }
15751 if (SWIG_IsTmpObj(res4)) {
15752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15753 } else {
15754 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15756 }
15757 return resultobj;
15758 fail:
15759 return NULL;
15760 }
15761
15762
15763 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15764 PyObject *resultobj = 0;
15765 wxImage *arg1 = (wxImage *) 0 ;
15766 byte result;
15767 void *argp1 = 0 ;
15768 int res1 = 0 ;
15769 PyObject *swig_obj[1] ;
15770
15771 if (!args) SWIG_fail;
15772 swig_obj[0] = args;
15773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15774 if (!SWIG_IsOK(res1)) {
15775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15776 }
15777 arg1 = reinterpret_cast< wxImage * >(argp1);
15778 {
15779 PyThreadState* __tstate = wxPyBeginAllowThreads();
15780 result = (byte)(arg1)->GetMaskRed();
15781 wxPyEndAllowThreads(__tstate);
15782 if (PyErr_Occurred()) SWIG_fail;
15783 }
15784 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15785 return resultobj;
15786 fail:
15787 return NULL;
15788 }
15789
15790
15791 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15792 PyObject *resultobj = 0;
15793 wxImage *arg1 = (wxImage *) 0 ;
15794 byte result;
15795 void *argp1 = 0 ;
15796 int res1 = 0 ;
15797 PyObject *swig_obj[1] ;
15798
15799 if (!args) SWIG_fail;
15800 swig_obj[0] = args;
15801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15802 if (!SWIG_IsOK(res1)) {
15803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15804 }
15805 arg1 = reinterpret_cast< wxImage * >(argp1);
15806 {
15807 PyThreadState* __tstate = wxPyBeginAllowThreads();
15808 result = (byte)(arg1)->GetMaskGreen();
15809 wxPyEndAllowThreads(__tstate);
15810 if (PyErr_Occurred()) SWIG_fail;
15811 }
15812 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15813 return resultobj;
15814 fail:
15815 return NULL;
15816 }
15817
15818
15819 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15820 PyObject *resultobj = 0;
15821 wxImage *arg1 = (wxImage *) 0 ;
15822 byte result;
15823 void *argp1 = 0 ;
15824 int res1 = 0 ;
15825 PyObject *swig_obj[1] ;
15826
15827 if (!args) SWIG_fail;
15828 swig_obj[0] = args;
15829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15830 if (!SWIG_IsOK(res1)) {
15831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15832 }
15833 arg1 = reinterpret_cast< wxImage * >(argp1);
15834 {
15835 PyThreadState* __tstate = wxPyBeginAllowThreads();
15836 result = (byte)(arg1)->GetMaskBlue();
15837 wxPyEndAllowThreads(__tstate);
15838 if (PyErr_Occurred()) SWIG_fail;
15839 }
15840 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15841 return resultobj;
15842 fail:
15843 return NULL;
15844 }
15845
15846
15847 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15848 PyObject *resultobj = 0;
15849 wxImage *arg1 = (wxImage *) 0 ;
15850 bool arg2 = (bool) true ;
15851 void *argp1 = 0 ;
15852 int res1 = 0 ;
15853 bool val2 ;
15854 int ecode2 = 0 ;
15855 PyObject * obj0 = 0 ;
15856 PyObject * obj1 = 0 ;
15857 char * kwnames[] = {
15858 (char *) "self",(char *) "mask", NULL
15859 };
15860
15861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15863 if (!SWIG_IsOK(res1)) {
15864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15865 }
15866 arg1 = reinterpret_cast< wxImage * >(argp1);
15867 if (obj1) {
15868 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15869 if (!SWIG_IsOK(ecode2)) {
15870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15871 }
15872 arg2 = static_cast< bool >(val2);
15873 }
15874 {
15875 PyThreadState* __tstate = wxPyBeginAllowThreads();
15876 (arg1)->SetMask(arg2);
15877 wxPyEndAllowThreads(__tstate);
15878 if (PyErr_Occurred()) SWIG_fail;
15879 }
15880 resultobj = SWIG_Py_Void();
15881 return resultobj;
15882 fail:
15883 return NULL;
15884 }
15885
15886
15887 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15888 PyObject *resultobj = 0;
15889 wxImage *arg1 = (wxImage *) 0 ;
15890 bool result;
15891 void *argp1 = 0 ;
15892 int res1 = 0 ;
15893 PyObject *swig_obj[1] ;
15894
15895 if (!args) SWIG_fail;
15896 swig_obj[0] = args;
15897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15898 if (!SWIG_IsOK(res1)) {
15899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15900 }
15901 arg1 = reinterpret_cast< wxImage * >(argp1);
15902 {
15903 PyThreadState* __tstate = wxPyBeginAllowThreads();
15904 result = (bool)(arg1)->HasMask();
15905 wxPyEndAllowThreads(__tstate);
15906 if (PyErr_Occurred()) SWIG_fail;
15907 }
15908 {
15909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15910 }
15911 return resultobj;
15912 fail:
15913 return NULL;
15914 }
15915
15916
15917 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15918 PyObject *resultobj = 0;
15919 wxImage *arg1 = (wxImage *) 0 ;
15920 double arg2 ;
15921 wxPoint *arg3 = 0 ;
15922 bool arg4 = (bool) true ;
15923 wxPoint *arg5 = (wxPoint *) NULL ;
15924 SwigValueWrapper<wxImage > result;
15925 void *argp1 = 0 ;
15926 int res1 = 0 ;
15927 double val2 ;
15928 int ecode2 = 0 ;
15929 wxPoint temp3 ;
15930 bool val4 ;
15931 int ecode4 = 0 ;
15932 void *argp5 = 0 ;
15933 int res5 = 0 ;
15934 PyObject * obj0 = 0 ;
15935 PyObject * obj1 = 0 ;
15936 PyObject * obj2 = 0 ;
15937 PyObject * obj3 = 0 ;
15938 PyObject * obj4 = 0 ;
15939 char * kwnames[] = {
15940 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15941 };
15942
15943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15945 if (!SWIG_IsOK(res1)) {
15946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15947 }
15948 arg1 = reinterpret_cast< wxImage * >(argp1);
15949 ecode2 = SWIG_AsVal_double(obj1, &val2);
15950 if (!SWIG_IsOK(ecode2)) {
15951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15952 }
15953 arg2 = static_cast< double >(val2);
15954 {
15955 arg3 = &temp3;
15956 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15957 }
15958 if (obj3) {
15959 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15960 if (!SWIG_IsOK(ecode4)) {
15961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15962 }
15963 arg4 = static_cast< bool >(val4);
15964 }
15965 if (obj4) {
15966 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15967 if (!SWIG_IsOK(res5)) {
15968 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15969 }
15970 arg5 = reinterpret_cast< wxPoint * >(argp5);
15971 }
15972 {
15973 PyThreadState* __tstate = wxPyBeginAllowThreads();
15974 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15975 wxPyEndAllowThreads(__tstate);
15976 if (PyErr_Occurred()) SWIG_fail;
15977 }
15978 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15979 return resultobj;
15980 fail:
15981 return NULL;
15982 }
15983
15984
15985 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15986 PyObject *resultobj = 0;
15987 wxImage *arg1 = (wxImage *) 0 ;
15988 bool arg2 = (bool) true ;
15989 SwigValueWrapper<wxImage > result;
15990 void *argp1 = 0 ;
15991 int res1 = 0 ;
15992 bool val2 ;
15993 int ecode2 = 0 ;
15994 PyObject * obj0 = 0 ;
15995 PyObject * obj1 = 0 ;
15996 char * kwnames[] = {
15997 (char *) "self",(char *) "clockwise", NULL
15998 };
15999
16000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16002 if (!SWIG_IsOK(res1)) {
16003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16004 }
16005 arg1 = reinterpret_cast< wxImage * >(argp1);
16006 if (obj1) {
16007 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16008 if (!SWIG_IsOK(ecode2)) {
16009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16010 }
16011 arg2 = static_cast< bool >(val2);
16012 }
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 result = (arg1)->Rotate90(arg2);
16016 wxPyEndAllowThreads(__tstate);
16017 if (PyErr_Occurred()) SWIG_fail;
16018 }
16019 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16020 return resultobj;
16021 fail:
16022 return NULL;
16023 }
16024
16025
16026 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16027 PyObject *resultobj = 0;
16028 wxImage *arg1 = (wxImage *) 0 ;
16029 bool arg2 = (bool) true ;
16030 SwigValueWrapper<wxImage > result;
16031 void *argp1 = 0 ;
16032 int res1 = 0 ;
16033 bool val2 ;
16034 int ecode2 = 0 ;
16035 PyObject * obj0 = 0 ;
16036 PyObject * obj1 = 0 ;
16037 char * kwnames[] = {
16038 (char *) "self",(char *) "horizontally", NULL
16039 };
16040
16041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16043 if (!SWIG_IsOK(res1)) {
16044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16045 }
16046 arg1 = reinterpret_cast< wxImage * >(argp1);
16047 if (obj1) {
16048 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16049 if (!SWIG_IsOK(ecode2)) {
16050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16051 }
16052 arg2 = static_cast< bool >(val2);
16053 }
16054 {
16055 PyThreadState* __tstate = wxPyBeginAllowThreads();
16056 result = (arg1)->Mirror(arg2);
16057 wxPyEndAllowThreads(__tstate);
16058 if (PyErr_Occurred()) SWIG_fail;
16059 }
16060 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16061 return resultobj;
16062 fail:
16063 return NULL;
16064 }
16065
16066
16067 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16068 PyObject *resultobj = 0;
16069 wxImage *arg1 = (wxImage *) 0 ;
16070 byte arg2 ;
16071 byte arg3 ;
16072 byte arg4 ;
16073 byte arg5 ;
16074 byte arg6 ;
16075 byte arg7 ;
16076 void *argp1 = 0 ;
16077 int res1 = 0 ;
16078 unsigned char val2 ;
16079 int ecode2 = 0 ;
16080 unsigned char val3 ;
16081 int ecode3 = 0 ;
16082 unsigned char val4 ;
16083 int ecode4 = 0 ;
16084 unsigned char val5 ;
16085 int ecode5 = 0 ;
16086 unsigned char val6 ;
16087 int ecode6 = 0 ;
16088 unsigned char val7 ;
16089 int ecode7 = 0 ;
16090 PyObject * obj0 = 0 ;
16091 PyObject * obj1 = 0 ;
16092 PyObject * obj2 = 0 ;
16093 PyObject * obj3 = 0 ;
16094 PyObject * obj4 = 0 ;
16095 PyObject * obj5 = 0 ;
16096 PyObject * obj6 = 0 ;
16097 char * kwnames[] = {
16098 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16099 };
16100
16101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16103 if (!SWIG_IsOK(res1)) {
16104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16105 }
16106 arg1 = reinterpret_cast< wxImage * >(argp1);
16107 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16108 if (!SWIG_IsOK(ecode2)) {
16109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16110 }
16111 arg2 = static_cast< byte >(val2);
16112 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16113 if (!SWIG_IsOK(ecode3)) {
16114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16115 }
16116 arg3 = static_cast< byte >(val3);
16117 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16118 if (!SWIG_IsOK(ecode4)) {
16119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16120 }
16121 arg4 = static_cast< byte >(val4);
16122 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16123 if (!SWIG_IsOK(ecode5)) {
16124 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16125 }
16126 arg5 = static_cast< byte >(val5);
16127 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16128 if (!SWIG_IsOK(ecode6)) {
16129 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16130 }
16131 arg6 = static_cast< byte >(val6);
16132 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16133 if (!SWIG_IsOK(ecode7)) {
16134 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16135 }
16136 arg7 = static_cast< byte >(val7);
16137 {
16138 PyThreadState* __tstate = wxPyBeginAllowThreads();
16139 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16140 wxPyEndAllowThreads(__tstate);
16141 if (PyErr_Occurred()) SWIG_fail;
16142 }
16143 resultobj = SWIG_Py_Void();
16144 return resultobj;
16145 fail:
16146 return NULL;
16147 }
16148
16149
16150 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16151 PyObject *resultobj = 0;
16152 wxImage *arg1 = (wxImage *) 0 ;
16153 double arg2 = (double) 0.299 ;
16154 double arg3 = (double) 0.587 ;
16155 double arg4 = (double) 0.114 ;
16156 SwigValueWrapper<wxImage > result;
16157 void *argp1 = 0 ;
16158 int res1 = 0 ;
16159 double val2 ;
16160 int ecode2 = 0 ;
16161 double val3 ;
16162 int ecode3 = 0 ;
16163 double val4 ;
16164 int ecode4 = 0 ;
16165 PyObject * obj0 = 0 ;
16166 PyObject * obj1 = 0 ;
16167 PyObject * obj2 = 0 ;
16168 PyObject * obj3 = 0 ;
16169 char * kwnames[] = {
16170 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16171 };
16172
16173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16175 if (!SWIG_IsOK(res1)) {
16176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16177 }
16178 arg1 = reinterpret_cast< wxImage * >(argp1);
16179 if (obj1) {
16180 ecode2 = SWIG_AsVal_double(obj1, &val2);
16181 if (!SWIG_IsOK(ecode2)) {
16182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16183 }
16184 arg2 = static_cast< double >(val2);
16185 }
16186 if (obj2) {
16187 ecode3 = SWIG_AsVal_double(obj2, &val3);
16188 if (!SWIG_IsOK(ecode3)) {
16189 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16190 }
16191 arg3 = static_cast< double >(val3);
16192 }
16193 if (obj3) {
16194 ecode4 = SWIG_AsVal_double(obj3, &val4);
16195 if (!SWIG_IsOK(ecode4)) {
16196 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16197 }
16198 arg4 = static_cast< double >(val4);
16199 }
16200 {
16201 PyThreadState* __tstate = wxPyBeginAllowThreads();
16202 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16203 wxPyEndAllowThreads(__tstate);
16204 if (PyErr_Occurred()) SWIG_fail;
16205 }
16206 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16207 return resultobj;
16208 fail:
16209 return NULL;
16210 }
16211
16212
16213 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16214 PyObject *resultobj = 0;
16215 wxImage *arg1 = (wxImage *) 0 ;
16216 byte arg2 ;
16217 byte arg3 ;
16218 byte arg4 ;
16219 SwigValueWrapper<wxImage > result;
16220 void *argp1 = 0 ;
16221 int res1 = 0 ;
16222 unsigned char val2 ;
16223 int ecode2 = 0 ;
16224 unsigned char val3 ;
16225 int ecode3 = 0 ;
16226 unsigned char val4 ;
16227 int ecode4 = 0 ;
16228 PyObject * obj0 = 0 ;
16229 PyObject * obj1 = 0 ;
16230 PyObject * obj2 = 0 ;
16231 PyObject * obj3 = 0 ;
16232 char * kwnames[] = {
16233 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16234 };
16235
16236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16238 if (!SWIG_IsOK(res1)) {
16239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16240 }
16241 arg1 = reinterpret_cast< wxImage * >(argp1);
16242 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16243 if (!SWIG_IsOK(ecode2)) {
16244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16245 }
16246 arg2 = static_cast< byte >(val2);
16247 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16248 if (!SWIG_IsOK(ecode3)) {
16249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16250 }
16251 arg3 = static_cast< byte >(val3);
16252 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16253 if (!SWIG_IsOK(ecode4)) {
16254 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16255 }
16256 arg4 = static_cast< byte >(val4);
16257 {
16258 PyThreadState* __tstate = wxPyBeginAllowThreads();
16259 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16260 wxPyEndAllowThreads(__tstate);
16261 if (PyErr_Occurred()) SWIG_fail;
16262 }
16263 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16264 return resultobj;
16265 fail:
16266 return NULL;
16267 }
16268
16269
16270 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16271 PyObject *resultobj = 0;
16272 wxImage *arg1 = (wxImage *) 0 ;
16273 wxString *arg2 = 0 ;
16274 wxString *arg3 = 0 ;
16275 void *argp1 = 0 ;
16276 int res1 = 0 ;
16277 bool temp2 = false ;
16278 bool temp3 = false ;
16279 PyObject * obj0 = 0 ;
16280 PyObject * obj1 = 0 ;
16281 PyObject * obj2 = 0 ;
16282 char * kwnames[] = {
16283 (char *) "self",(char *) "name",(char *) "value", NULL
16284 };
16285
16286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16288 if (!SWIG_IsOK(res1)) {
16289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16290 }
16291 arg1 = reinterpret_cast< wxImage * >(argp1);
16292 {
16293 arg2 = wxString_in_helper(obj1);
16294 if (arg2 == NULL) SWIG_fail;
16295 temp2 = true;
16296 }
16297 {
16298 arg3 = wxString_in_helper(obj2);
16299 if (arg3 == NULL) SWIG_fail;
16300 temp3 = true;
16301 }
16302 {
16303 PyThreadState* __tstate = wxPyBeginAllowThreads();
16304 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16305 wxPyEndAllowThreads(__tstate);
16306 if (PyErr_Occurred()) SWIG_fail;
16307 }
16308 resultobj = SWIG_Py_Void();
16309 {
16310 if (temp2)
16311 delete arg2;
16312 }
16313 {
16314 if (temp3)
16315 delete arg3;
16316 }
16317 return resultobj;
16318 fail:
16319 {
16320 if (temp2)
16321 delete arg2;
16322 }
16323 {
16324 if (temp3)
16325 delete arg3;
16326 }
16327 return NULL;
16328 }
16329
16330
16331 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16332 PyObject *resultobj = 0;
16333 wxImage *arg1 = (wxImage *) 0 ;
16334 wxString *arg2 = 0 ;
16335 int arg3 ;
16336 void *argp1 = 0 ;
16337 int res1 = 0 ;
16338 bool temp2 = false ;
16339 int val3 ;
16340 int ecode3 = 0 ;
16341 PyObject * obj0 = 0 ;
16342 PyObject * obj1 = 0 ;
16343 PyObject * obj2 = 0 ;
16344 char * kwnames[] = {
16345 (char *) "self",(char *) "name",(char *) "value", NULL
16346 };
16347
16348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16350 if (!SWIG_IsOK(res1)) {
16351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16352 }
16353 arg1 = reinterpret_cast< wxImage * >(argp1);
16354 {
16355 arg2 = wxString_in_helper(obj1);
16356 if (arg2 == NULL) SWIG_fail;
16357 temp2 = true;
16358 }
16359 ecode3 = SWIG_AsVal_int(obj2, &val3);
16360 if (!SWIG_IsOK(ecode3)) {
16361 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16362 }
16363 arg3 = static_cast< int >(val3);
16364 {
16365 PyThreadState* __tstate = wxPyBeginAllowThreads();
16366 (arg1)->SetOption((wxString const &)*arg2,arg3);
16367 wxPyEndAllowThreads(__tstate);
16368 if (PyErr_Occurred()) SWIG_fail;
16369 }
16370 resultobj = SWIG_Py_Void();
16371 {
16372 if (temp2)
16373 delete arg2;
16374 }
16375 return resultobj;
16376 fail:
16377 {
16378 if (temp2)
16379 delete arg2;
16380 }
16381 return NULL;
16382 }
16383
16384
16385 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16386 PyObject *resultobj = 0;
16387 wxImage *arg1 = (wxImage *) 0 ;
16388 wxString *arg2 = 0 ;
16389 wxString result;
16390 void *argp1 = 0 ;
16391 int res1 = 0 ;
16392 bool temp2 = false ;
16393 PyObject * obj0 = 0 ;
16394 PyObject * obj1 = 0 ;
16395 char * kwnames[] = {
16396 (char *) "self",(char *) "name", NULL
16397 };
16398
16399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16401 if (!SWIG_IsOK(res1)) {
16402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16403 }
16404 arg1 = reinterpret_cast< wxImage * >(argp1);
16405 {
16406 arg2 = wxString_in_helper(obj1);
16407 if (arg2 == NULL) SWIG_fail;
16408 temp2 = true;
16409 }
16410 {
16411 PyThreadState* __tstate = wxPyBeginAllowThreads();
16412 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16413 wxPyEndAllowThreads(__tstate);
16414 if (PyErr_Occurred()) SWIG_fail;
16415 }
16416 {
16417 #if wxUSE_UNICODE
16418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16419 #else
16420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16421 #endif
16422 }
16423 {
16424 if (temp2)
16425 delete arg2;
16426 }
16427 return resultobj;
16428 fail:
16429 {
16430 if (temp2)
16431 delete arg2;
16432 }
16433 return NULL;
16434 }
16435
16436
16437 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16438 PyObject *resultobj = 0;
16439 wxImage *arg1 = (wxImage *) 0 ;
16440 wxString *arg2 = 0 ;
16441 int result;
16442 void *argp1 = 0 ;
16443 int res1 = 0 ;
16444 bool temp2 = false ;
16445 PyObject * obj0 = 0 ;
16446 PyObject * obj1 = 0 ;
16447 char * kwnames[] = {
16448 (char *) "self",(char *) "name", NULL
16449 };
16450
16451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16453 if (!SWIG_IsOK(res1)) {
16454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16455 }
16456 arg1 = reinterpret_cast< wxImage * >(argp1);
16457 {
16458 arg2 = wxString_in_helper(obj1);
16459 if (arg2 == NULL) SWIG_fail;
16460 temp2 = true;
16461 }
16462 {
16463 PyThreadState* __tstate = wxPyBeginAllowThreads();
16464 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16465 wxPyEndAllowThreads(__tstate);
16466 if (PyErr_Occurred()) SWIG_fail;
16467 }
16468 resultobj = SWIG_From_int(static_cast< int >(result));
16469 {
16470 if (temp2)
16471 delete arg2;
16472 }
16473 return resultobj;
16474 fail:
16475 {
16476 if (temp2)
16477 delete arg2;
16478 }
16479 return NULL;
16480 }
16481
16482
16483 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16484 PyObject *resultobj = 0;
16485 wxImage *arg1 = (wxImage *) 0 ;
16486 wxString *arg2 = 0 ;
16487 bool result;
16488 void *argp1 = 0 ;
16489 int res1 = 0 ;
16490 bool temp2 = false ;
16491 PyObject * obj0 = 0 ;
16492 PyObject * obj1 = 0 ;
16493 char * kwnames[] = {
16494 (char *) "self",(char *) "name", NULL
16495 };
16496
16497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16499 if (!SWIG_IsOK(res1)) {
16500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16501 }
16502 arg1 = reinterpret_cast< wxImage * >(argp1);
16503 {
16504 arg2 = wxString_in_helper(obj1);
16505 if (arg2 == NULL) SWIG_fail;
16506 temp2 = true;
16507 }
16508 {
16509 PyThreadState* __tstate = wxPyBeginAllowThreads();
16510 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16511 wxPyEndAllowThreads(__tstate);
16512 if (PyErr_Occurred()) SWIG_fail;
16513 }
16514 {
16515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16516 }
16517 {
16518 if (temp2)
16519 delete arg2;
16520 }
16521 return resultobj;
16522 fail:
16523 {
16524 if (temp2)
16525 delete arg2;
16526 }
16527 return NULL;
16528 }
16529
16530
16531 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16532 PyObject *resultobj = 0;
16533 wxImage *arg1 = (wxImage *) 0 ;
16534 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16535 unsigned long result;
16536 void *argp1 = 0 ;
16537 int res1 = 0 ;
16538 unsigned long val2 ;
16539 int ecode2 = 0 ;
16540 PyObject * obj0 = 0 ;
16541 PyObject * obj1 = 0 ;
16542 char * kwnames[] = {
16543 (char *) "self",(char *) "stopafter", NULL
16544 };
16545
16546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16548 if (!SWIG_IsOK(res1)) {
16549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16550 }
16551 arg1 = reinterpret_cast< wxImage * >(argp1);
16552 if (obj1) {
16553 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16554 if (!SWIG_IsOK(ecode2)) {
16555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16556 }
16557 arg2 = static_cast< unsigned long >(val2);
16558 }
16559 {
16560 PyThreadState* __tstate = wxPyBeginAllowThreads();
16561 result = (unsigned long)(arg1)->CountColours(arg2);
16562 wxPyEndAllowThreads(__tstate);
16563 if (PyErr_Occurred()) SWIG_fail;
16564 }
16565 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16566 return resultobj;
16567 fail:
16568 return NULL;
16569 }
16570
16571
16572 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16573 PyObject *resultobj = 0;
16574 wxImage *arg1 = (wxImage *) 0 ;
16575 wxImageHistogram *arg2 = 0 ;
16576 unsigned long result;
16577 void *argp1 = 0 ;
16578 int res1 = 0 ;
16579 void *argp2 = 0 ;
16580 int res2 = 0 ;
16581 PyObject * obj0 = 0 ;
16582 PyObject * obj1 = 0 ;
16583 char * kwnames[] = {
16584 (char *) "self",(char *) "h", NULL
16585 };
16586
16587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16589 if (!SWIG_IsOK(res1)) {
16590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16591 }
16592 arg1 = reinterpret_cast< wxImage * >(argp1);
16593 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16594 if (!SWIG_IsOK(res2)) {
16595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16596 }
16597 if (!argp2) {
16598 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16599 }
16600 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16601 {
16602 PyThreadState* __tstate = wxPyBeginAllowThreads();
16603 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16604 wxPyEndAllowThreads(__tstate);
16605 if (PyErr_Occurred()) SWIG_fail;
16606 }
16607 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16608 return resultobj;
16609 fail:
16610 return NULL;
16611 }
16612
16613
16614 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16615 PyObject *resultobj = 0;
16616 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16617 void *argp1 = 0 ;
16618 int res1 = 0 ;
16619 PyObject * obj0 = 0 ;
16620 char * kwnames[] = {
16621 (char *) "handler", NULL
16622 };
16623
16624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16626 if (!SWIG_IsOK(res1)) {
16627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16628 }
16629 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16630 {
16631 PyThreadState* __tstate = wxPyBeginAllowThreads();
16632 wxImage::AddHandler(arg1);
16633 wxPyEndAllowThreads(__tstate);
16634 if (PyErr_Occurred()) SWIG_fail;
16635 }
16636 resultobj = SWIG_Py_Void();
16637 return resultobj;
16638 fail:
16639 return NULL;
16640 }
16641
16642
16643 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16644 PyObject *resultobj = 0;
16645 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16646 void *argp1 = 0 ;
16647 int res1 = 0 ;
16648 PyObject * obj0 = 0 ;
16649 char * kwnames[] = {
16650 (char *) "handler", NULL
16651 };
16652
16653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16655 if (!SWIG_IsOK(res1)) {
16656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16657 }
16658 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16659 {
16660 PyThreadState* __tstate = wxPyBeginAllowThreads();
16661 wxImage::InsertHandler(arg1);
16662 wxPyEndAllowThreads(__tstate);
16663 if (PyErr_Occurred()) SWIG_fail;
16664 }
16665 resultobj = SWIG_Py_Void();
16666 return resultobj;
16667 fail:
16668 return NULL;
16669 }
16670
16671
16672 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16673 PyObject *resultobj = 0;
16674 wxString *arg1 = 0 ;
16675 bool result;
16676 bool temp1 = false ;
16677 PyObject * obj0 = 0 ;
16678 char * kwnames[] = {
16679 (char *) "name", NULL
16680 };
16681
16682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16683 {
16684 arg1 = wxString_in_helper(obj0);
16685 if (arg1 == NULL) SWIG_fail;
16686 temp1 = true;
16687 }
16688 {
16689 PyThreadState* __tstate = wxPyBeginAllowThreads();
16690 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16691 wxPyEndAllowThreads(__tstate);
16692 if (PyErr_Occurred()) SWIG_fail;
16693 }
16694 {
16695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16696 }
16697 {
16698 if (temp1)
16699 delete arg1;
16700 }
16701 return resultobj;
16702 fail:
16703 {
16704 if (temp1)
16705 delete arg1;
16706 }
16707 return NULL;
16708 }
16709
16710
16711 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16712 PyObject *resultobj = 0;
16713 PyObject *result = 0 ;
16714
16715 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16716 {
16717 PyThreadState* __tstate = wxPyBeginAllowThreads();
16718 result = (PyObject *)wxImage_GetHandlers();
16719 wxPyEndAllowThreads(__tstate);
16720 if (PyErr_Occurred()) SWIG_fail;
16721 }
16722 resultobj = result;
16723 return resultobj;
16724 fail:
16725 return NULL;
16726 }
16727
16728
16729 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16730 PyObject *resultobj = 0;
16731 wxString result;
16732
16733 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16734 {
16735 PyThreadState* __tstate = wxPyBeginAllowThreads();
16736 result = wxImage::GetImageExtWildcard();
16737 wxPyEndAllowThreads(__tstate);
16738 if (PyErr_Occurred()) SWIG_fail;
16739 }
16740 {
16741 #if wxUSE_UNICODE
16742 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16743 #else
16744 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16745 #endif
16746 }
16747 return resultobj;
16748 fail:
16749 return NULL;
16750 }
16751
16752
16753 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16754 PyObject *resultobj = 0;
16755 wxImage *arg1 = (wxImage *) 0 ;
16756 int arg2 = (int) -1 ;
16757 wxBitmap result;
16758 void *argp1 = 0 ;
16759 int res1 = 0 ;
16760 int val2 ;
16761 int ecode2 = 0 ;
16762 PyObject * obj0 = 0 ;
16763 PyObject * obj1 = 0 ;
16764 char * kwnames[] = {
16765 (char *) "self",(char *) "depth", NULL
16766 };
16767
16768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16770 if (!SWIG_IsOK(res1)) {
16771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16772 }
16773 arg1 = reinterpret_cast< wxImage * >(argp1);
16774 if (obj1) {
16775 ecode2 = SWIG_AsVal_int(obj1, &val2);
16776 if (!SWIG_IsOK(ecode2)) {
16777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16778 }
16779 arg2 = static_cast< int >(val2);
16780 }
16781 {
16782 if (!wxPyCheckForApp()) SWIG_fail;
16783 PyThreadState* __tstate = wxPyBeginAllowThreads();
16784 result = wxImage_ConvertToBitmap(arg1,arg2);
16785 wxPyEndAllowThreads(__tstate);
16786 if (PyErr_Occurred()) SWIG_fail;
16787 }
16788 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16789 return resultobj;
16790 fail:
16791 return NULL;
16792 }
16793
16794
16795 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16796 PyObject *resultobj = 0;
16797 wxImage *arg1 = (wxImage *) 0 ;
16798 byte arg2 ;
16799 byte arg3 ;
16800 byte arg4 ;
16801 wxBitmap result;
16802 void *argp1 = 0 ;
16803 int res1 = 0 ;
16804 unsigned char val2 ;
16805 int ecode2 = 0 ;
16806 unsigned char val3 ;
16807 int ecode3 = 0 ;
16808 unsigned char val4 ;
16809 int ecode4 = 0 ;
16810 PyObject * obj0 = 0 ;
16811 PyObject * obj1 = 0 ;
16812 PyObject * obj2 = 0 ;
16813 PyObject * obj3 = 0 ;
16814 char * kwnames[] = {
16815 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16816 };
16817
16818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16820 if (!SWIG_IsOK(res1)) {
16821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16822 }
16823 arg1 = reinterpret_cast< wxImage * >(argp1);
16824 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16825 if (!SWIG_IsOK(ecode2)) {
16826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16827 }
16828 arg2 = static_cast< byte >(val2);
16829 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16830 if (!SWIG_IsOK(ecode3)) {
16831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16832 }
16833 arg3 = static_cast< byte >(val3);
16834 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16835 if (!SWIG_IsOK(ecode4)) {
16836 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16837 }
16838 arg4 = static_cast< byte >(val4);
16839 {
16840 if (!wxPyCheckForApp()) SWIG_fail;
16841 PyThreadState* __tstate = wxPyBeginAllowThreads();
16842 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16843 wxPyEndAllowThreads(__tstate);
16844 if (PyErr_Occurred()) SWIG_fail;
16845 }
16846 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16847 return resultobj;
16848 fail:
16849 return NULL;
16850 }
16851
16852
16853 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16854 PyObject *resultobj = 0;
16855 wxImage *arg1 = (wxImage *) 0 ;
16856 double arg2 ;
16857 void *argp1 = 0 ;
16858 int res1 = 0 ;
16859 double val2 ;
16860 int ecode2 = 0 ;
16861 PyObject * obj0 = 0 ;
16862 PyObject * obj1 = 0 ;
16863 char * kwnames[] = {
16864 (char *) "self",(char *) "angle", NULL
16865 };
16866
16867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16869 if (!SWIG_IsOK(res1)) {
16870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16871 }
16872 arg1 = reinterpret_cast< wxImage * >(argp1);
16873 ecode2 = SWIG_AsVal_double(obj1, &val2);
16874 if (!SWIG_IsOK(ecode2)) {
16875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16876 }
16877 arg2 = static_cast< double >(val2);
16878 {
16879 PyThreadState* __tstate = wxPyBeginAllowThreads();
16880 (arg1)->RotateHue(arg2);
16881 wxPyEndAllowThreads(__tstate);
16882 if (PyErr_Occurred()) SWIG_fail;
16883 }
16884 resultobj = SWIG_Py_Void();
16885 return resultobj;
16886 fail:
16887 return NULL;
16888 }
16889
16890
16891 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16892 PyObject *resultobj = 0;
16893 wxImage_RGBValue arg1 ;
16894 wxImage_HSVValue result;
16895 void *argp1 ;
16896 int res1 = 0 ;
16897 PyObject * obj0 = 0 ;
16898 char * kwnames[] = {
16899 (char *) "rgb", NULL
16900 };
16901
16902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16903 {
16904 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16905 if (!SWIG_IsOK(res1)) {
16906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16907 }
16908 if (!argp1) {
16909 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16910 } else {
16911 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16912 arg1 = *temp;
16913 if (SWIG_IsNewObj(res1)) delete temp;
16914 }
16915 }
16916 {
16917 PyThreadState* __tstate = wxPyBeginAllowThreads();
16918 result = wxImage::RGBtoHSV(arg1);
16919 wxPyEndAllowThreads(__tstate);
16920 if (PyErr_Occurred()) SWIG_fail;
16921 }
16922 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16923 return resultobj;
16924 fail:
16925 return NULL;
16926 }
16927
16928
16929 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16930 PyObject *resultobj = 0;
16931 wxImage_HSVValue arg1 ;
16932 wxImage_RGBValue result;
16933 void *argp1 ;
16934 int res1 = 0 ;
16935 PyObject * obj0 = 0 ;
16936 char * kwnames[] = {
16937 (char *) "hsv", NULL
16938 };
16939
16940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16941 {
16942 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16943 if (!SWIG_IsOK(res1)) {
16944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16945 }
16946 if (!argp1) {
16947 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16948 } else {
16949 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16950 arg1 = *temp;
16951 if (SWIG_IsNewObj(res1)) delete temp;
16952 }
16953 }
16954 {
16955 PyThreadState* __tstate = wxPyBeginAllowThreads();
16956 result = wxImage::HSVtoRGB(arg1);
16957 wxPyEndAllowThreads(__tstate);
16958 if (PyErr_Occurred()) SWIG_fail;
16959 }
16960 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16961 return resultobj;
16962 fail:
16963 return NULL;
16964 }
16965
16966
16967 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16968 PyObject *obj;
16969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16970 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16971 return SWIG_Py_Void();
16972 }
16973
16974 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16975 return SWIG_Python_InitShadowInstance(args);
16976 }
16977
16978 SWIGINTERN int NullImage_set(PyObject *) {
16979 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16980 return 1;
16981 }
16982
16983
16984 SWIGINTERN PyObject *NullImage_get(void) {
16985 PyObject *pyobj = 0;
16986
16987 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16988 return pyobj;
16989 }
16990
16991
16992 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16993 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16994 return 1;
16995 }
16996
16997
16998 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16999 PyObject *pyobj = 0;
17000
17001 {
17002 #if wxUSE_UNICODE
17003 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17004 #else
17005 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17006 #endif
17007 }
17008 return pyobj;
17009 }
17010
17011
17012 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17013 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17014 return 1;
17015 }
17016
17017
17018 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17019 PyObject *pyobj = 0;
17020
17021 {
17022 #if wxUSE_UNICODE
17023 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17024 #else
17025 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17026 #endif
17027 }
17028 return pyobj;
17029 }
17030
17031
17032 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17033 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17034 return 1;
17035 }
17036
17037
17038 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17039 PyObject *pyobj = 0;
17040
17041 {
17042 #if wxUSE_UNICODE
17043 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17044 #else
17045 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17046 #endif
17047 }
17048 return pyobj;
17049 }
17050
17051
17052 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17053 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17054 return 1;
17055 }
17056
17057
17058 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17059 PyObject *pyobj = 0;
17060
17061 {
17062 #if wxUSE_UNICODE
17063 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17064 #else
17065 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17066 #endif
17067 }
17068 return pyobj;
17069 }
17070
17071
17072 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17073 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17074 return 1;
17075 }
17076
17077
17078 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17079 PyObject *pyobj = 0;
17080
17081 {
17082 #if wxUSE_UNICODE
17083 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17084 #else
17085 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17086 #endif
17087 }
17088 return pyobj;
17089 }
17090
17091
17092 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17093 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17094 return 1;
17095 }
17096
17097
17098 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17099 PyObject *pyobj = 0;
17100
17101 {
17102 #if wxUSE_UNICODE
17103 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17104 #else
17105 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17106 #endif
17107 }
17108 return pyobj;
17109 }
17110
17111
17112 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17113 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17114 return 1;
17115 }
17116
17117
17118 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17119 PyObject *pyobj = 0;
17120
17121 {
17122 #if wxUSE_UNICODE
17123 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17124 #else
17125 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17126 #endif
17127 }
17128 return pyobj;
17129 }
17130
17131
17132 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17133 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17134 return 1;
17135 }
17136
17137
17138 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17139 PyObject *pyobj = 0;
17140
17141 {
17142 #if wxUSE_UNICODE
17143 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17144 #else
17145 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17146 #endif
17147 }
17148 return pyobj;
17149 }
17150
17151
17152 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17153 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17154 return 1;
17155 }
17156
17157
17158 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17159 PyObject *pyobj = 0;
17160
17161 {
17162 #if wxUSE_UNICODE
17163 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17164 #else
17165 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17166 #endif
17167 }
17168 return pyobj;
17169 }
17170
17171
17172 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17173 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17174 return 1;
17175 }
17176
17177
17178 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17179 PyObject *pyobj = 0;
17180
17181 {
17182 #if wxUSE_UNICODE
17183 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17184 #else
17185 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17186 #endif
17187 }
17188 return pyobj;
17189 }
17190
17191
17192 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17193 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17194 return 1;
17195 }
17196
17197
17198 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17199 PyObject *pyobj = 0;
17200
17201 {
17202 #if wxUSE_UNICODE
17203 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17204 #else
17205 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17206 #endif
17207 }
17208 return pyobj;
17209 }
17210
17211
17212 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17213 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17214 return 1;
17215 }
17216
17217
17218 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17219 PyObject *pyobj = 0;
17220
17221 {
17222 #if wxUSE_UNICODE
17223 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17224 #else
17225 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17226 #endif
17227 }
17228 return pyobj;
17229 }
17230
17231
17232 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17233 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17234 return 1;
17235 }
17236
17237
17238 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17239 PyObject *pyobj = 0;
17240
17241 {
17242 #if wxUSE_UNICODE
17243 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17244 #else
17245 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17246 #endif
17247 }
17248 return pyobj;
17249 }
17250
17251
17252 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17253 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17254 return 1;
17255 }
17256
17257
17258 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17259 PyObject *pyobj = 0;
17260
17261 {
17262 #if wxUSE_UNICODE
17263 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17264 #else
17265 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17266 #endif
17267 }
17268 return pyobj;
17269 }
17270
17271
17272 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17273 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17274 return 1;
17275 }
17276
17277
17278 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17279 PyObject *pyobj = 0;
17280
17281 {
17282 #if wxUSE_UNICODE
17283 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17284 #else
17285 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17286 #endif
17287 }
17288 return pyobj;
17289 }
17290
17291
17292 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17293 PyObject *resultobj = 0;
17294 wxBMPHandler *result = 0 ;
17295
17296 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17297 {
17298 PyThreadState* __tstate = wxPyBeginAllowThreads();
17299 result = (wxBMPHandler *)new wxBMPHandler();
17300 wxPyEndAllowThreads(__tstate);
17301 if (PyErr_Occurred()) SWIG_fail;
17302 }
17303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17304 return resultobj;
17305 fail:
17306 return NULL;
17307 }
17308
17309
17310 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17311 PyObject *obj;
17312 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17313 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17314 return SWIG_Py_Void();
17315 }
17316
17317 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17318 return SWIG_Python_InitShadowInstance(args);
17319 }
17320
17321 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17322 PyObject *resultobj = 0;
17323 wxICOHandler *result = 0 ;
17324
17325 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17326 {
17327 PyThreadState* __tstate = wxPyBeginAllowThreads();
17328 result = (wxICOHandler *)new wxICOHandler();
17329 wxPyEndAllowThreads(__tstate);
17330 if (PyErr_Occurred()) SWIG_fail;
17331 }
17332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17333 return resultobj;
17334 fail:
17335 return NULL;
17336 }
17337
17338
17339 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17340 PyObject *obj;
17341 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17342 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17343 return SWIG_Py_Void();
17344 }
17345
17346 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17347 return SWIG_Python_InitShadowInstance(args);
17348 }
17349
17350 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17351 PyObject *resultobj = 0;
17352 wxCURHandler *result = 0 ;
17353
17354 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17355 {
17356 PyThreadState* __tstate = wxPyBeginAllowThreads();
17357 result = (wxCURHandler *)new wxCURHandler();
17358 wxPyEndAllowThreads(__tstate);
17359 if (PyErr_Occurred()) SWIG_fail;
17360 }
17361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17362 return resultobj;
17363 fail:
17364 return NULL;
17365 }
17366
17367
17368 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17369 PyObject *obj;
17370 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17371 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17372 return SWIG_Py_Void();
17373 }
17374
17375 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17376 return SWIG_Python_InitShadowInstance(args);
17377 }
17378
17379 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17380 PyObject *resultobj = 0;
17381 wxANIHandler *result = 0 ;
17382
17383 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17384 {
17385 PyThreadState* __tstate = wxPyBeginAllowThreads();
17386 result = (wxANIHandler *)new wxANIHandler();
17387 wxPyEndAllowThreads(__tstate);
17388 if (PyErr_Occurred()) SWIG_fail;
17389 }
17390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17391 return resultobj;
17392 fail:
17393 return NULL;
17394 }
17395
17396
17397 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17398 PyObject *obj;
17399 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17400 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17401 return SWIG_Py_Void();
17402 }
17403
17404 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17405 return SWIG_Python_InitShadowInstance(args);
17406 }
17407
17408 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17409 PyObject *resultobj = 0;
17410 wxPNGHandler *result = 0 ;
17411
17412 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17413 {
17414 PyThreadState* __tstate = wxPyBeginAllowThreads();
17415 result = (wxPNGHandler *)new wxPNGHandler();
17416 wxPyEndAllowThreads(__tstate);
17417 if (PyErr_Occurred()) SWIG_fail;
17418 }
17419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17420 return resultobj;
17421 fail:
17422 return NULL;
17423 }
17424
17425
17426 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17427 PyObject *obj;
17428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17429 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17430 return SWIG_Py_Void();
17431 }
17432
17433 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17434 return SWIG_Python_InitShadowInstance(args);
17435 }
17436
17437 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17438 PyObject *resultobj = 0;
17439 wxGIFHandler *result = 0 ;
17440
17441 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17442 {
17443 PyThreadState* __tstate = wxPyBeginAllowThreads();
17444 result = (wxGIFHandler *)new wxGIFHandler();
17445 wxPyEndAllowThreads(__tstate);
17446 if (PyErr_Occurred()) SWIG_fail;
17447 }
17448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17449 return resultobj;
17450 fail:
17451 return NULL;
17452 }
17453
17454
17455 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17456 PyObject *obj;
17457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17458 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17459 return SWIG_Py_Void();
17460 }
17461
17462 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17463 return SWIG_Python_InitShadowInstance(args);
17464 }
17465
17466 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17467 PyObject *resultobj = 0;
17468 wxPCXHandler *result = 0 ;
17469
17470 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17471 {
17472 PyThreadState* __tstate = wxPyBeginAllowThreads();
17473 result = (wxPCXHandler *)new wxPCXHandler();
17474 wxPyEndAllowThreads(__tstate);
17475 if (PyErr_Occurred()) SWIG_fail;
17476 }
17477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17478 return resultobj;
17479 fail:
17480 return NULL;
17481 }
17482
17483
17484 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17485 PyObject *obj;
17486 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17487 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17488 return SWIG_Py_Void();
17489 }
17490
17491 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17492 return SWIG_Python_InitShadowInstance(args);
17493 }
17494
17495 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17496 PyObject *resultobj = 0;
17497 wxJPEGHandler *result = 0 ;
17498
17499 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17500 {
17501 PyThreadState* __tstate = wxPyBeginAllowThreads();
17502 result = (wxJPEGHandler *)new wxJPEGHandler();
17503 wxPyEndAllowThreads(__tstate);
17504 if (PyErr_Occurred()) SWIG_fail;
17505 }
17506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17507 return resultobj;
17508 fail:
17509 return NULL;
17510 }
17511
17512
17513 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17514 PyObject *obj;
17515 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17516 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17517 return SWIG_Py_Void();
17518 }
17519
17520 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17521 return SWIG_Python_InitShadowInstance(args);
17522 }
17523
17524 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17525 PyObject *resultobj = 0;
17526 wxPNMHandler *result = 0 ;
17527
17528 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17529 {
17530 PyThreadState* __tstate = wxPyBeginAllowThreads();
17531 result = (wxPNMHandler *)new wxPNMHandler();
17532 wxPyEndAllowThreads(__tstate);
17533 if (PyErr_Occurred()) SWIG_fail;
17534 }
17535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17536 return resultobj;
17537 fail:
17538 return NULL;
17539 }
17540
17541
17542 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17543 PyObject *obj;
17544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17545 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17546 return SWIG_Py_Void();
17547 }
17548
17549 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17550 return SWIG_Python_InitShadowInstance(args);
17551 }
17552
17553 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17554 PyObject *resultobj = 0;
17555 wxXPMHandler *result = 0 ;
17556
17557 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17558 {
17559 PyThreadState* __tstate = wxPyBeginAllowThreads();
17560 result = (wxXPMHandler *)new wxXPMHandler();
17561 wxPyEndAllowThreads(__tstate);
17562 if (PyErr_Occurred()) SWIG_fail;
17563 }
17564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17565 return resultobj;
17566 fail:
17567 return NULL;
17568 }
17569
17570
17571 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17572 PyObject *obj;
17573 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17574 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17575 return SWIG_Py_Void();
17576 }
17577
17578 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17579 return SWIG_Python_InitShadowInstance(args);
17580 }
17581
17582 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17583 PyObject *resultobj = 0;
17584 wxTIFFHandler *result = 0 ;
17585
17586 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17587 {
17588 PyThreadState* __tstate = wxPyBeginAllowThreads();
17589 result = (wxTIFFHandler *)new wxTIFFHandler();
17590 wxPyEndAllowThreads(__tstate);
17591 if (PyErr_Occurred()) SWIG_fail;
17592 }
17593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17594 return resultobj;
17595 fail:
17596 return NULL;
17597 }
17598
17599
17600 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17601 PyObject *obj;
17602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17603 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17604 return SWIG_Py_Void();
17605 }
17606
17607 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17608 return SWIG_Python_InitShadowInstance(args);
17609 }
17610
17611 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17612 PyObject *resultobj = 0;
17613 wxImage *arg1 = 0 ;
17614 wxImage *arg2 = 0 ;
17615 int arg3 = (int) 236 ;
17616 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17617 bool result;
17618 void *argp1 = 0 ;
17619 int res1 = 0 ;
17620 void *argp2 = 0 ;
17621 int res2 = 0 ;
17622 int val3 ;
17623 int ecode3 = 0 ;
17624 int val4 ;
17625 int ecode4 = 0 ;
17626 PyObject * obj0 = 0 ;
17627 PyObject * obj1 = 0 ;
17628 PyObject * obj2 = 0 ;
17629 PyObject * obj3 = 0 ;
17630 char * kwnames[] = {
17631 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17632 };
17633
17634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17635 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17636 if (!SWIG_IsOK(res1)) {
17637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17638 }
17639 if (!argp1) {
17640 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17641 }
17642 arg1 = reinterpret_cast< wxImage * >(argp1);
17643 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17644 if (!SWIG_IsOK(res2)) {
17645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17646 }
17647 if (!argp2) {
17648 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17649 }
17650 arg2 = reinterpret_cast< wxImage * >(argp2);
17651 if (obj2) {
17652 ecode3 = SWIG_AsVal_int(obj2, &val3);
17653 if (!SWIG_IsOK(ecode3)) {
17654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17655 }
17656 arg3 = static_cast< int >(val3);
17657 }
17658 if (obj3) {
17659 ecode4 = SWIG_AsVal_int(obj3, &val4);
17660 if (!SWIG_IsOK(ecode4)) {
17661 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17662 }
17663 arg4 = static_cast< int >(val4);
17664 }
17665 {
17666 PyThreadState* __tstate = wxPyBeginAllowThreads();
17667 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17668 wxPyEndAllowThreads(__tstate);
17669 if (PyErr_Occurred()) SWIG_fail;
17670 }
17671 {
17672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17673 }
17674 return resultobj;
17675 fail:
17676 return NULL;
17677 }
17678
17679
17680 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17681 PyObject *obj;
17682 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17683 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17684 return SWIG_Py_Void();
17685 }
17686
17687 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17688 PyObject *resultobj = 0;
17689 wxEvtHandler *result = 0 ;
17690
17691 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17692 {
17693 PyThreadState* __tstate = wxPyBeginAllowThreads();
17694 result = (wxEvtHandler *)new wxEvtHandler();
17695 wxPyEndAllowThreads(__tstate);
17696 if (PyErr_Occurred()) SWIG_fail;
17697 }
17698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17699 return resultobj;
17700 fail:
17701 return NULL;
17702 }
17703
17704
17705 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17706 PyObject *resultobj = 0;
17707 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17708 wxEvtHandler *result = 0 ;
17709 void *argp1 = 0 ;
17710 int res1 = 0 ;
17711 PyObject *swig_obj[1] ;
17712
17713 if (!args) SWIG_fail;
17714 swig_obj[0] = args;
17715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17716 if (!SWIG_IsOK(res1)) {
17717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17718 }
17719 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17720 {
17721 PyThreadState* __tstate = wxPyBeginAllowThreads();
17722 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17723 wxPyEndAllowThreads(__tstate);
17724 if (PyErr_Occurred()) SWIG_fail;
17725 }
17726 {
17727 resultobj = wxPyMake_wxObject(result, 0);
17728 }
17729 return resultobj;
17730 fail:
17731 return NULL;
17732 }
17733
17734
17735 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17736 PyObject *resultobj = 0;
17737 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17738 wxEvtHandler *result = 0 ;
17739 void *argp1 = 0 ;
17740 int res1 = 0 ;
17741 PyObject *swig_obj[1] ;
17742
17743 if (!args) SWIG_fail;
17744 swig_obj[0] = args;
17745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17746 if (!SWIG_IsOK(res1)) {
17747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17748 }
17749 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17750 {
17751 PyThreadState* __tstate = wxPyBeginAllowThreads();
17752 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17753 wxPyEndAllowThreads(__tstate);
17754 if (PyErr_Occurred()) SWIG_fail;
17755 }
17756 {
17757 resultobj = wxPyMake_wxObject(result, 0);
17758 }
17759 return resultobj;
17760 fail:
17761 return NULL;
17762 }
17763
17764
17765 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17766 PyObject *resultobj = 0;
17767 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17768 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17769 void *argp1 = 0 ;
17770 int res1 = 0 ;
17771 void *argp2 = 0 ;
17772 int res2 = 0 ;
17773 PyObject * obj0 = 0 ;
17774 PyObject * obj1 = 0 ;
17775 char * kwnames[] = {
17776 (char *) "self",(char *) "handler", NULL
17777 };
17778
17779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17781 if (!SWIG_IsOK(res1)) {
17782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17783 }
17784 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17785 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17786 if (!SWIG_IsOK(res2)) {
17787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17788 }
17789 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17790 {
17791 PyThreadState* __tstate = wxPyBeginAllowThreads();
17792 (arg1)->SetNextHandler(arg2);
17793 wxPyEndAllowThreads(__tstate);
17794 if (PyErr_Occurred()) SWIG_fail;
17795 }
17796 resultobj = SWIG_Py_Void();
17797 return resultobj;
17798 fail:
17799 return NULL;
17800 }
17801
17802
17803 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17804 PyObject *resultobj = 0;
17805 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17806 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17807 void *argp1 = 0 ;
17808 int res1 = 0 ;
17809 void *argp2 = 0 ;
17810 int res2 = 0 ;
17811 PyObject * obj0 = 0 ;
17812 PyObject * obj1 = 0 ;
17813 char * kwnames[] = {
17814 (char *) "self",(char *) "handler", NULL
17815 };
17816
17817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17819 if (!SWIG_IsOK(res1)) {
17820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17821 }
17822 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17823 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17824 if (!SWIG_IsOK(res2)) {
17825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17826 }
17827 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17828 {
17829 PyThreadState* __tstate = wxPyBeginAllowThreads();
17830 (arg1)->SetPreviousHandler(arg2);
17831 wxPyEndAllowThreads(__tstate);
17832 if (PyErr_Occurred()) SWIG_fail;
17833 }
17834 resultobj = SWIG_Py_Void();
17835 return resultobj;
17836 fail:
17837 return NULL;
17838 }
17839
17840
17841 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17842 PyObject *resultobj = 0;
17843 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17844 bool result;
17845 void *argp1 = 0 ;
17846 int res1 = 0 ;
17847 PyObject *swig_obj[1] ;
17848
17849 if (!args) SWIG_fail;
17850 swig_obj[0] = args;
17851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17852 if (!SWIG_IsOK(res1)) {
17853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17854 }
17855 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17856 {
17857 PyThreadState* __tstate = wxPyBeginAllowThreads();
17858 result = (bool)(arg1)->GetEvtHandlerEnabled();
17859 wxPyEndAllowThreads(__tstate);
17860 if (PyErr_Occurred()) SWIG_fail;
17861 }
17862 {
17863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17864 }
17865 return resultobj;
17866 fail:
17867 return NULL;
17868 }
17869
17870
17871 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17872 PyObject *resultobj = 0;
17873 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17874 bool arg2 ;
17875 void *argp1 = 0 ;
17876 int res1 = 0 ;
17877 bool val2 ;
17878 int ecode2 = 0 ;
17879 PyObject * obj0 = 0 ;
17880 PyObject * obj1 = 0 ;
17881 char * kwnames[] = {
17882 (char *) "self",(char *) "enabled", NULL
17883 };
17884
17885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17887 if (!SWIG_IsOK(res1)) {
17888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17889 }
17890 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17891 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17892 if (!SWIG_IsOK(ecode2)) {
17893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17894 }
17895 arg2 = static_cast< bool >(val2);
17896 {
17897 PyThreadState* __tstate = wxPyBeginAllowThreads();
17898 (arg1)->SetEvtHandlerEnabled(arg2);
17899 wxPyEndAllowThreads(__tstate);
17900 if (PyErr_Occurred()) SWIG_fail;
17901 }
17902 resultobj = SWIG_Py_Void();
17903 return resultobj;
17904 fail:
17905 return NULL;
17906 }
17907
17908
17909 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17910 PyObject *resultobj = 0;
17911 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17912 wxEvent *arg2 = 0 ;
17913 bool result;
17914 void *argp1 = 0 ;
17915 int res1 = 0 ;
17916 void *argp2 = 0 ;
17917 int res2 = 0 ;
17918 PyObject * obj0 = 0 ;
17919 PyObject * obj1 = 0 ;
17920 char * kwnames[] = {
17921 (char *) "self",(char *) "event", NULL
17922 };
17923
17924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17926 if (!SWIG_IsOK(res1)) {
17927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17928 }
17929 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17930 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17931 if (!SWIG_IsOK(res2)) {
17932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17933 }
17934 if (!argp2) {
17935 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17936 }
17937 arg2 = reinterpret_cast< wxEvent * >(argp2);
17938 {
17939 PyThreadState* __tstate = wxPyBeginAllowThreads();
17940 result = (bool)(arg1)->ProcessEvent(*arg2);
17941 wxPyEndAllowThreads(__tstate);
17942 if (PyErr_Occurred()) SWIG_fail;
17943 }
17944 {
17945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17946 }
17947 return resultobj;
17948 fail:
17949 return NULL;
17950 }
17951
17952
17953 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17954 PyObject *resultobj = 0;
17955 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17956 wxEvent *arg2 = 0 ;
17957 void *argp1 = 0 ;
17958 int res1 = 0 ;
17959 void *argp2 = 0 ;
17960 int res2 = 0 ;
17961 PyObject * obj0 = 0 ;
17962 PyObject * obj1 = 0 ;
17963 char * kwnames[] = {
17964 (char *) "self",(char *) "event", NULL
17965 };
17966
17967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17969 if (!SWIG_IsOK(res1)) {
17970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17971 }
17972 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17973 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17974 if (!SWIG_IsOK(res2)) {
17975 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17976 }
17977 if (!argp2) {
17978 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17979 }
17980 arg2 = reinterpret_cast< wxEvent * >(argp2);
17981 {
17982 PyThreadState* __tstate = wxPyBeginAllowThreads();
17983 (arg1)->AddPendingEvent(*arg2);
17984 wxPyEndAllowThreads(__tstate);
17985 if (PyErr_Occurred()) SWIG_fail;
17986 }
17987 resultobj = SWIG_Py_Void();
17988 return resultobj;
17989 fail:
17990 return NULL;
17991 }
17992
17993
17994 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17995 PyObject *resultobj = 0;
17996 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17997 void *argp1 = 0 ;
17998 int res1 = 0 ;
17999 PyObject *swig_obj[1] ;
18000
18001 if (!args) SWIG_fail;
18002 swig_obj[0] = args;
18003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18004 if (!SWIG_IsOK(res1)) {
18005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18006 }
18007 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18008 {
18009 PyThreadState* __tstate = wxPyBeginAllowThreads();
18010 (arg1)->ProcessPendingEvents();
18011 wxPyEndAllowThreads(__tstate);
18012 if (PyErr_Occurred()) SWIG_fail;
18013 }
18014 resultobj = SWIG_Py_Void();
18015 return resultobj;
18016 fail:
18017 return NULL;
18018 }
18019
18020
18021 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18022 PyObject *resultobj = 0;
18023 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18024 int arg2 ;
18025 int arg3 ;
18026 int arg4 ;
18027 PyObject *arg5 = (PyObject *) 0 ;
18028 void *argp1 = 0 ;
18029 int res1 = 0 ;
18030 int val2 ;
18031 int ecode2 = 0 ;
18032 int val3 ;
18033 int ecode3 = 0 ;
18034 int val4 ;
18035 int ecode4 = 0 ;
18036 PyObject * obj0 = 0 ;
18037 PyObject * obj1 = 0 ;
18038 PyObject * obj2 = 0 ;
18039 PyObject * obj3 = 0 ;
18040 PyObject * obj4 = 0 ;
18041 char * kwnames[] = {
18042 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18043 };
18044
18045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18047 if (!SWIG_IsOK(res1)) {
18048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18049 }
18050 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18051 ecode2 = SWIG_AsVal_int(obj1, &val2);
18052 if (!SWIG_IsOK(ecode2)) {
18053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18054 }
18055 arg2 = static_cast< int >(val2);
18056 ecode3 = SWIG_AsVal_int(obj2, &val3);
18057 if (!SWIG_IsOK(ecode3)) {
18058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18059 }
18060 arg3 = static_cast< int >(val3);
18061 ecode4 = SWIG_AsVal_int(obj3, &val4);
18062 if (!SWIG_IsOK(ecode4)) {
18063 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18064 }
18065 arg4 = static_cast< int >(val4);
18066 arg5 = obj4;
18067 {
18068 PyThreadState* __tstate = wxPyBeginAllowThreads();
18069 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18070 wxPyEndAllowThreads(__tstate);
18071 if (PyErr_Occurred()) SWIG_fail;
18072 }
18073 resultobj = SWIG_Py_Void();
18074 return resultobj;
18075 fail:
18076 return NULL;
18077 }
18078
18079
18080 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18081 PyObject *resultobj = 0;
18082 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18083 int arg2 ;
18084 int arg3 = (int) -1 ;
18085 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18086 bool result;
18087 void *argp1 = 0 ;
18088 int res1 = 0 ;
18089 int val2 ;
18090 int ecode2 = 0 ;
18091 int val3 ;
18092 int ecode3 = 0 ;
18093 int val4 ;
18094 int ecode4 = 0 ;
18095 PyObject * obj0 = 0 ;
18096 PyObject * obj1 = 0 ;
18097 PyObject * obj2 = 0 ;
18098 PyObject * obj3 = 0 ;
18099 char * kwnames[] = {
18100 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18101 };
18102
18103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18105 if (!SWIG_IsOK(res1)) {
18106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18107 }
18108 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18109 ecode2 = SWIG_AsVal_int(obj1, &val2);
18110 if (!SWIG_IsOK(ecode2)) {
18111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18112 }
18113 arg2 = static_cast< int >(val2);
18114 if (obj2) {
18115 ecode3 = SWIG_AsVal_int(obj2, &val3);
18116 if (!SWIG_IsOK(ecode3)) {
18117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18118 }
18119 arg3 = static_cast< int >(val3);
18120 }
18121 if (obj3) {
18122 ecode4 = SWIG_AsVal_int(obj3, &val4);
18123 if (!SWIG_IsOK(ecode4)) {
18124 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18125 }
18126 arg4 = static_cast< wxEventType >(val4);
18127 }
18128 {
18129 PyThreadState* __tstate = wxPyBeginAllowThreads();
18130 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18131 wxPyEndAllowThreads(__tstate);
18132 if (PyErr_Occurred()) SWIG_fail;
18133 }
18134 {
18135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18136 }
18137 return resultobj;
18138 fail:
18139 return NULL;
18140 }
18141
18142
18143 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18144 PyObject *resultobj = 0;
18145 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18146 PyObject *arg2 = (PyObject *) 0 ;
18147 bool arg3 = (bool) true ;
18148 void *argp1 = 0 ;
18149 int res1 = 0 ;
18150 bool val3 ;
18151 int ecode3 = 0 ;
18152 PyObject * obj0 = 0 ;
18153 PyObject * obj1 = 0 ;
18154 PyObject * obj2 = 0 ;
18155 char * kwnames[] = {
18156 (char *) "self",(char *) "_self",(char *) "incref", NULL
18157 };
18158
18159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18161 if (!SWIG_IsOK(res1)) {
18162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18163 }
18164 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18165 arg2 = obj1;
18166 if (obj2) {
18167 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18168 if (!SWIG_IsOK(ecode3)) {
18169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18170 }
18171 arg3 = static_cast< bool >(val3);
18172 }
18173 {
18174 PyThreadState* __tstate = wxPyBeginAllowThreads();
18175 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18176 wxPyEndAllowThreads(__tstate);
18177 if (PyErr_Occurred()) SWIG_fail;
18178 }
18179 resultobj = SWIG_Py_Void();
18180 return resultobj;
18181 fail:
18182 return NULL;
18183 }
18184
18185
18186 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18187 PyObject *obj;
18188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18189 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18190 return SWIG_Py_Void();
18191 }
18192
18193 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18194 return SWIG_Python_InitShadowInstance(args);
18195 }
18196
18197 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18198 PyObject *resultobj = 0;
18199 wxEventType result;
18200
18201 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18202 {
18203 PyThreadState* __tstate = wxPyBeginAllowThreads();
18204 result = (wxEventType)wxNewEventType();
18205 wxPyEndAllowThreads(__tstate);
18206 if (PyErr_Occurred()) SWIG_fail;
18207 }
18208 resultobj = SWIG_From_int(static_cast< int >(result));
18209 return resultobj;
18210 fail:
18211 return NULL;
18212 }
18213
18214
18215 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18216 PyObject *resultobj = 0;
18217 wxEvent *arg1 = (wxEvent *) 0 ;
18218 void *argp1 = 0 ;
18219 int res1 = 0 ;
18220 PyObject *swig_obj[1] ;
18221
18222 if (!args) SWIG_fail;
18223 swig_obj[0] = args;
18224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18225 if (!SWIG_IsOK(res1)) {
18226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18227 }
18228 arg1 = reinterpret_cast< wxEvent * >(argp1);
18229 {
18230 PyThreadState* __tstate = wxPyBeginAllowThreads();
18231 delete arg1;
18232
18233 wxPyEndAllowThreads(__tstate);
18234 if (PyErr_Occurred()) SWIG_fail;
18235 }
18236 resultobj = SWIG_Py_Void();
18237 return resultobj;
18238 fail:
18239 return NULL;
18240 }
18241
18242
18243 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18244 PyObject *resultobj = 0;
18245 wxEvent *arg1 = (wxEvent *) 0 ;
18246 wxEventType arg2 ;
18247 void *argp1 = 0 ;
18248 int res1 = 0 ;
18249 int val2 ;
18250 int ecode2 = 0 ;
18251 PyObject * obj0 = 0 ;
18252 PyObject * obj1 = 0 ;
18253 char * kwnames[] = {
18254 (char *) "self",(char *) "typ", NULL
18255 };
18256
18257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18259 if (!SWIG_IsOK(res1)) {
18260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18261 }
18262 arg1 = reinterpret_cast< wxEvent * >(argp1);
18263 ecode2 = SWIG_AsVal_int(obj1, &val2);
18264 if (!SWIG_IsOK(ecode2)) {
18265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18266 }
18267 arg2 = static_cast< wxEventType >(val2);
18268 {
18269 PyThreadState* __tstate = wxPyBeginAllowThreads();
18270 (arg1)->SetEventType(arg2);
18271 wxPyEndAllowThreads(__tstate);
18272 if (PyErr_Occurred()) SWIG_fail;
18273 }
18274 resultobj = SWIG_Py_Void();
18275 return resultobj;
18276 fail:
18277 return NULL;
18278 }
18279
18280
18281 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18282 PyObject *resultobj = 0;
18283 wxEvent *arg1 = (wxEvent *) 0 ;
18284 wxEventType result;
18285 void *argp1 = 0 ;
18286 int res1 = 0 ;
18287 PyObject *swig_obj[1] ;
18288
18289 if (!args) SWIG_fail;
18290 swig_obj[0] = args;
18291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18292 if (!SWIG_IsOK(res1)) {
18293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18294 }
18295 arg1 = reinterpret_cast< wxEvent * >(argp1);
18296 {
18297 PyThreadState* __tstate = wxPyBeginAllowThreads();
18298 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18299 wxPyEndAllowThreads(__tstate);
18300 if (PyErr_Occurred()) SWIG_fail;
18301 }
18302 resultobj = SWIG_From_int(static_cast< int >(result));
18303 return resultobj;
18304 fail:
18305 return NULL;
18306 }
18307
18308
18309 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18310 PyObject *resultobj = 0;
18311 wxEvent *arg1 = (wxEvent *) 0 ;
18312 wxObject *result = 0 ;
18313 void *argp1 = 0 ;
18314 int res1 = 0 ;
18315 PyObject *swig_obj[1] ;
18316
18317 if (!args) SWIG_fail;
18318 swig_obj[0] = args;
18319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18320 if (!SWIG_IsOK(res1)) {
18321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18322 }
18323 arg1 = reinterpret_cast< wxEvent * >(argp1);
18324 {
18325 PyThreadState* __tstate = wxPyBeginAllowThreads();
18326 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18327 wxPyEndAllowThreads(__tstate);
18328 if (PyErr_Occurred()) SWIG_fail;
18329 }
18330 {
18331 resultobj = wxPyMake_wxObject(result, (bool)0);
18332 }
18333 return resultobj;
18334 fail:
18335 return NULL;
18336 }
18337
18338
18339 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18340 PyObject *resultobj = 0;
18341 wxEvent *arg1 = (wxEvent *) 0 ;
18342 wxObject *arg2 = (wxObject *) 0 ;
18343 void *argp1 = 0 ;
18344 int res1 = 0 ;
18345 void *argp2 = 0 ;
18346 int res2 = 0 ;
18347 PyObject * obj0 = 0 ;
18348 PyObject * obj1 = 0 ;
18349 char * kwnames[] = {
18350 (char *) "self",(char *) "obj", NULL
18351 };
18352
18353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18355 if (!SWIG_IsOK(res1)) {
18356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18357 }
18358 arg1 = reinterpret_cast< wxEvent * >(argp1);
18359 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18360 if (!SWIG_IsOK(res2)) {
18361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18362 }
18363 arg2 = reinterpret_cast< wxObject * >(argp2);
18364 {
18365 PyThreadState* __tstate = wxPyBeginAllowThreads();
18366 (arg1)->SetEventObject(arg2);
18367 wxPyEndAllowThreads(__tstate);
18368 if (PyErr_Occurred()) SWIG_fail;
18369 }
18370 resultobj = SWIG_Py_Void();
18371 return resultobj;
18372 fail:
18373 return NULL;
18374 }
18375
18376
18377 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18378 PyObject *resultobj = 0;
18379 wxEvent *arg1 = (wxEvent *) 0 ;
18380 long result;
18381 void *argp1 = 0 ;
18382 int res1 = 0 ;
18383 PyObject *swig_obj[1] ;
18384
18385 if (!args) SWIG_fail;
18386 swig_obj[0] = args;
18387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18388 if (!SWIG_IsOK(res1)) {
18389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18390 }
18391 arg1 = reinterpret_cast< wxEvent * >(argp1);
18392 {
18393 PyThreadState* __tstate = wxPyBeginAllowThreads();
18394 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18395 wxPyEndAllowThreads(__tstate);
18396 if (PyErr_Occurred()) SWIG_fail;
18397 }
18398 resultobj = SWIG_From_long(static_cast< long >(result));
18399 return resultobj;
18400 fail:
18401 return NULL;
18402 }
18403
18404
18405 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18406 PyObject *resultobj = 0;
18407 wxEvent *arg1 = (wxEvent *) 0 ;
18408 long arg2 = (long) 0 ;
18409 void *argp1 = 0 ;
18410 int res1 = 0 ;
18411 long val2 ;
18412 int ecode2 = 0 ;
18413 PyObject * obj0 = 0 ;
18414 PyObject * obj1 = 0 ;
18415 char * kwnames[] = {
18416 (char *) "self",(char *) "ts", NULL
18417 };
18418
18419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18421 if (!SWIG_IsOK(res1)) {
18422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18423 }
18424 arg1 = reinterpret_cast< wxEvent * >(argp1);
18425 if (obj1) {
18426 ecode2 = SWIG_AsVal_long(obj1, &val2);
18427 if (!SWIG_IsOK(ecode2)) {
18428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18429 }
18430 arg2 = static_cast< long >(val2);
18431 }
18432 {
18433 PyThreadState* __tstate = wxPyBeginAllowThreads();
18434 (arg1)->SetTimestamp(arg2);
18435 wxPyEndAllowThreads(__tstate);
18436 if (PyErr_Occurred()) SWIG_fail;
18437 }
18438 resultobj = SWIG_Py_Void();
18439 return resultobj;
18440 fail:
18441 return NULL;
18442 }
18443
18444
18445 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18446 PyObject *resultobj = 0;
18447 wxEvent *arg1 = (wxEvent *) 0 ;
18448 int result;
18449 void *argp1 = 0 ;
18450 int res1 = 0 ;
18451 PyObject *swig_obj[1] ;
18452
18453 if (!args) SWIG_fail;
18454 swig_obj[0] = args;
18455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18456 if (!SWIG_IsOK(res1)) {
18457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18458 }
18459 arg1 = reinterpret_cast< wxEvent * >(argp1);
18460 {
18461 PyThreadState* __tstate = wxPyBeginAllowThreads();
18462 result = (int)((wxEvent const *)arg1)->GetId();
18463 wxPyEndAllowThreads(__tstate);
18464 if (PyErr_Occurred()) SWIG_fail;
18465 }
18466 resultobj = SWIG_From_int(static_cast< int >(result));
18467 return resultobj;
18468 fail:
18469 return NULL;
18470 }
18471
18472
18473 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18474 PyObject *resultobj = 0;
18475 wxEvent *arg1 = (wxEvent *) 0 ;
18476 int arg2 ;
18477 void *argp1 = 0 ;
18478 int res1 = 0 ;
18479 int val2 ;
18480 int ecode2 = 0 ;
18481 PyObject * obj0 = 0 ;
18482 PyObject * obj1 = 0 ;
18483 char * kwnames[] = {
18484 (char *) "self",(char *) "Id", NULL
18485 };
18486
18487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18489 if (!SWIG_IsOK(res1)) {
18490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18491 }
18492 arg1 = reinterpret_cast< wxEvent * >(argp1);
18493 ecode2 = SWIG_AsVal_int(obj1, &val2);
18494 if (!SWIG_IsOK(ecode2)) {
18495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18496 }
18497 arg2 = static_cast< int >(val2);
18498 {
18499 PyThreadState* __tstate = wxPyBeginAllowThreads();
18500 (arg1)->SetId(arg2);
18501 wxPyEndAllowThreads(__tstate);
18502 if (PyErr_Occurred()) SWIG_fail;
18503 }
18504 resultobj = SWIG_Py_Void();
18505 return resultobj;
18506 fail:
18507 return NULL;
18508 }
18509
18510
18511 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18512 PyObject *resultobj = 0;
18513 wxEvent *arg1 = (wxEvent *) 0 ;
18514 bool result;
18515 void *argp1 = 0 ;
18516 int res1 = 0 ;
18517 PyObject *swig_obj[1] ;
18518
18519 if (!args) SWIG_fail;
18520 swig_obj[0] = args;
18521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18522 if (!SWIG_IsOK(res1)) {
18523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18524 }
18525 arg1 = reinterpret_cast< wxEvent * >(argp1);
18526 {
18527 PyThreadState* __tstate = wxPyBeginAllowThreads();
18528 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18529 wxPyEndAllowThreads(__tstate);
18530 if (PyErr_Occurred()) SWIG_fail;
18531 }
18532 {
18533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18534 }
18535 return resultobj;
18536 fail:
18537 return NULL;
18538 }
18539
18540
18541 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18542 PyObject *resultobj = 0;
18543 wxEvent *arg1 = (wxEvent *) 0 ;
18544 bool arg2 = (bool) true ;
18545 void *argp1 = 0 ;
18546 int res1 = 0 ;
18547 bool val2 ;
18548 int ecode2 = 0 ;
18549 PyObject * obj0 = 0 ;
18550 PyObject * obj1 = 0 ;
18551 char * kwnames[] = {
18552 (char *) "self",(char *) "skip", NULL
18553 };
18554
18555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18557 if (!SWIG_IsOK(res1)) {
18558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18559 }
18560 arg1 = reinterpret_cast< wxEvent * >(argp1);
18561 if (obj1) {
18562 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18563 if (!SWIG_IsOK(ecode2)) {
18564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18565 }
18566 arg2 = static_cast< bool >(val2);
18567 }
18568 {
18569 PyThreadState* __tstate = wxPyBeginAllowThreads();
18570 (arg1)->Skip(arg2);
18571 wxPyEndAllowThreads(__tstate);
18572 if (PyErr_Occurred()) SWIG_fail;
18573 }
18574 resultobj = SWIG_Py_Void();
18575 return resultobj;
18576 fail:
18577 return NULL;
18578 }
18579
18580
18581 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18582 PyObject *resultobj = 0;
18583 wxEvent *arg1 = (wxEvent *) 0 ;
18584 bool result;
18585 void *argp1 = 0 ;
18586 int res1 = 0 ;
18587 PyObject *swig_obj[1] ;
18588
18589 if (!args) SWIG_fail;
18590 swig_obj[0] = args;
18591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18592 if (!SWIG_IsOK(res1)) {
18593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18594 }
18595 arg1 = reinterpret_cast< wxEvent * >(argp1);
18596 {
18597 PyThreadState* __tstate = wxPyBeginAllowThreads();
18598 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18599 wxPyEndAllowThreads(__tstate);
18600 if (PyErr_Occurred()) SWIG_fail;
18601 }
18602 {
18603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18604 }
18605 return resultobj;
18606 fail:
18607 return NULL;
18608 }
18609
18610
18611 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18612 PyObject *resultobj = 0;
18613 wxEvent *arg1 = (wxEvent *) 0 ;
18614 bool result;
18615 void *argp1 = 0 ;
18616 int res1 = 0 ;
18617 PyObject *swig_obj[1] ;
18618
18619 if (!args) SWIG_fail;
18620 swig_obj[0] = args;
18621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18622 if (!SWIG_IsOK(res1)) {
18623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18624 }
18625 arg1 = reinterpret_cast< wxEvent * >(argp1);
18626 {
18627 PyThreadState* __tstate = wxPyBeginAllowThreads();
18628 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18629 wxPyEndAllowThreads(__tstate);
18630 if (PyErr_Occurred()) SWIG_fail;
18631 }
18632 {
18633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18634 }
18635 return resultobj;
18636 fail:
18637 return NULL;
18638 }
18639
18640
18641 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18642 PyObject *resultobj = 0;
18643 wxEvent *arg1 = (wxEvent *) 0 ;
18644 int result;
18645 void *argp1 = 0 ;
18646 int res1 = 0 ;
18647 PyObject *swig_obj[1] ;
18648
18649 if (!args) SWIG_fail;
18650 swig_obj[0] = args;
18651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18652 if (!SWIG_IsOK(res1)) {
18653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18654 }
18655 arg1 = reinterpret_cast< wxEvent * >(argp1);
18656 {
18657 PyThreadState* __tstate = wxPyBeginAllowThreads();
18658 result = (int)(arg1)->StopPropagation();
18659 wxPyEndAllowThreads(__tstate);
18660 if (PyErr_Occurred()) SWIG_fail;
18661 }
18662 resultobj = SWIG_From_int(static_cast< int >(result));
18663 return resultobj;
18664 fail:
18665 return NULL;
18666 }
18667
18668
18669 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18670 PyObject *resultobj = 0;
18671 wxEvent *arg1 = (wxEvent *) 0 ;
18672 int arg2 ;
18673 void *argp1 = 0 ;
18674 int res1 = 0 ;
18675 int val2 ;
18676 int ecode2 = 0 ;
18677 PyObject * obj0 = 0 ;
18678 PyObject * obj1 = 0 ;
18679 char * kwnames[] = {
18680 (char *) "self",(char *) "propagationLevel", NULL
18681 };
18682
18683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18685 if (!SWIG_IsOK(res1)) {
18686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18687 }
18688 arg1 = reinterpret_cast< wxEvent * >(argp1);
18689 ecode2 = SWIG_AsVal_int(obj1, &val2);
18690 if (!SWIG_IsOK(ecode2)) {
18691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18692 }
18693 arg2 = static_cast< int >(val2);
18694 {
18695 PyThreadState* __tstate = wxPyBeginAllowThreads();
18696 (arg1)->ResumePropagation(arg2);
18697 wxPyEndAllowThreads(__tstate);
18698 if (PyErr_Occurred()) SWIG_fail;
18699 }
18700 resultobj = SWIG_Py_Void();
18701 return resultobj;
18702 fail:
18703 return NULL;
18704 }
18705
18706
18707 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18708 PyObject *resultobj = 0;
18709 wxEvent *arg1 = (wxEvent *) 0 ;
18710 wxEvent *result = 0 ;
18711 void *argp1 = 0 ;
18712 int res1 = 0 ;
18713 PyObject *swig_obj[1] ;
18714
18715 if (!args) SWIG_fail;
18716 swig_obj[0] = args;
18717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18718 if (!SWIG_IsOK(res1)) {
18719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18720 }
18721 arg1 = reinterpret_cast< wxEvent * >(argp1);
18722 {
18723 PyThreadState* __tstate = wxPyBeginAllowThreads();
18724 result = (wxEvent *)(arg1)->Clone();
18725 wxPyEndAllowThreads(__tstate);
18726 if (PyErr_Occurred()) SWIG_fail;
18727 }
18728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18729 return resultobj;
18730 fail:
18731 return NULL;
18732 }
18733
18734
18735 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18736 PyObject *obj;
18737 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18738 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18739 return SWIG_Py_Void();
18740 }
18741
18742 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18743 PyObject *resultobj = 0;
18744 wxEvent *arg1 = 0 ;
18745 wxPropagationDisabler *result = 0 ;
18746 void *argp1 = 0 ;
18747 int res1 = 0 ;
18748 PyObject * obj0 = 0 ;
18749 char * kwnames[] = {
18750 (char *) "event", NULL
18751 };
18752
18753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18754 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18755 if (!SWIG_IsOK(res1)) {
18756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18757 }
18758 if (!argp1) {
18759 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18760 }
18761 arg1 = reinterpret_cast< wxEvent * >(argp1);
18762 {
18763 PyThreadState* __tstate = wxPyBeginAllowThreads();
18764 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18765 wxPyEndAllowThreads(__tstate);
18766 if (PyErr_Occurred()) SWIG_fail;
18767 }
18768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18769 return resultobj;
18770 fail:
18771 return NULL;
18772 }
18773
18774
18775 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18776 PyObject *resultobj = 0;
18777 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18778 void *argp1 = 0 ;
18779 int res1 = 0 ;
18780 PyObject *swig_obj[1] ;
18781
18782 if (!args) SWIG_fail;
18783 swig_obj[0] = args;
18784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18785 if (!SWIG_IsOK(res1)) {
18786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18787 }
18788 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18789 {
18790 PyThreadState* __tstate = wxPyBeginAllowThreads();
18791 delete arg1;
18792
18793 wxPyEndAllowThreads(__tstate);
18794 if (PyErr_Occurred()) SWIG_fail;
18795 }
18796 resultobj = SWIG_Py_Void();
18797 return resultobj;
18798 fail:
18799 return NULL;
18800 }
18801
18802
18803 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18804 PyObject *obj;
18805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18806 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18807 return SWIG_Py_Void();
18808 }
18809
18810 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18811 return SWIG_Python_InitShadowInstance(args);
18812 }
18813
18814 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18815 PyObject *resultobj = 0;
18816 wxEvent *arg1 = 0 ;
18817 wxPropagateOnce *result = 0 ;
18818 void *argp1 = 0 ;
18819 int res1 = 0 ;
18820 PyObject * obj0 = 0 ;
18821 char * kwnames[] = {
18822 (char *) "event", NULL
18823 };
18824
18825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18826 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18827 if (!SWIG_IsOK(res1)) {
18828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18829 }
18830 if (!argp1) {
18831 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18832 }
18833 arg1 = reinterpret_cast< wxEvent * >(argp1);
18834 {
18835 PyThreadState* __tstate = wxPyBeginAllowThreads();
18836 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18837 wxPyEndAllowThreads(__tstate);
18838 if (PyErr_Occurred()) SWIG_fail;
18839 }
18840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18841 return resultobj;
18842 fail:
18843 return NULL;
18844 }
18845
18846
18847 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18848 PyObject *resultobj = 0;
18849 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18850 void *argp1 = 0 ;
18851 int res1 = 0 ;
18852 PyObject *swig_obj[1] ;
18853
18854 if (!args) SWIG_fail;
18855 swig_obj[0] = args;
18856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18857 if (!SWIG_IsOK(res1)) {
18858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18859 }
18860 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18861 {
18862 PyThreadState* __tstate = wxPyBeginAllowThreads();
18863 delete arg1;
18864
18865 wxPyEndAllowThreads(__tstate);
18866 if (PyErr_Occurred()) SWIG_fail;
18867 }
18868 resultobj = SWIG_Py_Void();
18869 return resultobj;
18870 fail:
18871 return NULL;
18872 }
18873
18874
18875 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18876 PyObject *obj;
18877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18878 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18879 return SWIG_Py_Void();
18880 }
18881
18882 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18883 return SWIG_Python_InitShadowInstance(args);
18884 }
18885
18886 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18887 PyObject *resultobj = 0;
18888 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18889 int arg2 = (int) 0 ;
18890 wxCommandEvent *result = 0 ;
18891 int val1 ;
18892 int ecode1 = 0 ;
18893 int val2 ;
18894 int ecode2 = 0 ;
18895 PyObject * obj0 = 0 ;
18896 PyObject * obj1 = 0 ;
18897 char * kwnames[] = {
18898 (char *) "commandType",(char *) "winid", NULL
18899 };
18900
18901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18902 if (obj0) {
18903 ecode1 = SWIG_AsVal_int(obj0, &val1);
18904 if (!SWIG_IsOK(ecode1)) {
18905 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18906 }
18907 arg1 = static_cast< wxEventType >(val1);
18908 }
18909 if (obj1) {
18910 ecode2 = SWIG_AsVal_int(obj1, &val2);
18911 if (!SWIG_IsOK(ecode2)) {
18912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18913 }
18914 arg2 = static_cast< int >(val2);
18915 }
18916 {
18917 PyThreadState* __tstate = wxPyBeginAllowThreads();
18918 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18919 wxPyEndAllowThreads(__tstate);
18920 if (PyErr_Occurred()) SWIG_fail;
18921 }
18922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18923 return resultobj;
18924 fail:
18925 return NULL;
18926 }
18927
18928
18929 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18930 PyObject *resultobj = 0;
18931 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18932 int result;
18933 void *argp1 = 0 ;
18934 int res1 = 0 ;
18935 PyObject *swig_obj[1] ;
18936
18937 if (!args) SWIG_fail;
18938 swig_obj[0] = args;
18939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18940 if (!SWIG_IsOK(res1)) {
18941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18942 }
18943 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18944 {
18945 PyThreadState* __tstate = wxPyBeginAllowThreads();
18946 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18947 wxPyEndAllowThreads(__tstate);
18948 if (PyErr_Occurred()) SWIG_fail;
18949 }
18950 resultobj = SWIG_From_int(static_cast< int >(result));
18951 return resultobj;
18952 fail:
18953 return NULL;
18954 }
18955
18956
18957 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18958 PyObject *resultobj = 0;
18959 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18960 wxString *arg2 = 0 ;
18961 void *argp1 = 0 ;
18962 int res1 = 0 ;
18963 bool temp2 = false ;
18964 PyObject * obj0 = 0 ;
18965 PyObject * obj1 = 0 ;
18966 char * kwnames[] = {
18967 (char *) "self",(char *) "s", NULL
18968 };
18969
18970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18972 if (!SWIG_IsOK(res1)) {
18973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18974 }
18975 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18976 {
18977 arg2 = wxString_in_helper(obj1);
18978 if (arg2 == NULL) SWIG_fail;
18979 temp2 = true;
18980 }
18981 {
18982 PyThreadState* __tstate = wxPyBeginAllowThreads();
18983 (arg1)->SetString((wxString const &)*arg2);
18984 wxPyEndAllowThreads(__tstate);
18985 if (PyErr_Occurred()) SWIG_fail;
18986 }
18987 resultobj = SWIG_Py_Void();
18988 {
18989 if (temp2)
18990 delete arg2;
18991 }
18992 return resultobj;
18993 fail:
18994 {
18995 if (temp2)
18996 delete arg2;
18997 }
18998 return NULL;
18999 }
19000
19001
19002 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19003 PyObject *resultobj = 0;
19004 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19005 wxString result;
19006 void *argp1 = 0 ;
19007 int res1 = 0 ;
19008 PyObject *swig_obj[1] ;
19009
19010 if (!args) SWIG_fail;
19011 swig_obj[0] = args;
19012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19013 if (!SWIG_IsOK(res1)) {
19014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19015 }
19016 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19017 {
19018 PyThreadState* __tstate = wxPyBeginAllowThreads();
19019 result = ((wxCommandEvent const *)arg1)->GetString();
19020 wxPyEndAllowThreads(__tstate);
19021 if (PyErr_Occurred()) SWIG_fail;
19022 }
19023 {
19024 #if wxUSE_UNICODE
19025 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19026 #else
19027 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19028 #endif
19029 }
19030 return resultobj;
19031 fail:
19032 return NULL;
19033 }
19034
19035
19036 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19037 PyObject *resultobj = 0;
19038 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19039 bool result;
19040 void *argp1 = 0 ;
19041 int res1 = 0 ;
19042 PyObject *swig_obj[1] ;
19043
19044 if (!args) SWIG_fail;
19045 swig_obj[0] = args;
19046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19047 if (!SWIG_IsOK(res1)) {
19048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19049 }
19050 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19051 {
19052 PyThreadState* __tstate = wxPyBeginAllowThreads();
19053 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19054 wxPyEndAllowThreads(__tstate);
19055 if (PyErr_Occurred()) SWIG_fail;
19056 }
19057 {
19058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19059 }
19060 return resultobj;
19061 fail:
19062 return NULL;
19063 }
19064
19065
19066 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19067 PyObject *resultobj = 0;
19068 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19069 bool result;
19070 void *argp1 = 0 ;
19071 int res1 = 0 ;
19072 PyObject *swig_obj[1] ;
19073
19074 if (!args) SWIG_fail;
19075 swig_obj[0] = args;
19076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19077 if (!SWIG_IsOK(res1)) {
19078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19079 }
19080 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19081 {
19082 PyThreadState* __tstate = wxPyBeginAllowThreads();
19083 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19084 wxPyEndAllowThreads(__tstate);
19085 if (PyErr_Occurred()) SWIG_fail;
19086 }
19087 {
19088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19089 }
19090 return resultobj;
19091 fail:
19092 return NULL;
19093 }
19094
19095
19096 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19097 PyObject *resultobj = 0;
19098 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19099 long arg2 ;
19100 void *argp1 = 0 ;
19101 int res1 = 0 ;
19102 long val2 ;
19103 int ecode2 = 0 ;
19104 PyObject * obj0 = 0 ;
19105 PyObject * obj1 = 0 ;
19106 char * kwnames[] = {
19107 (char *) "self",(char *) "extraLong", NULL
19108 };
19109
19110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19112 if (!SWIG_IsOK(res1)) {
19113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19114 }
19115 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19116 ecode2 = SWIG_AsVal_long(obj1, &val2);
19117 if (!SWIG_IsOK(ecode2)) {
19118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19119 }
19120 arg2 = static_cast< long >(val2);
19121 {
19122 PyThreadState* __tstate = wxPyBeginAllowThreads();
19123 (arg1)->SetExtraLong(arg2);
19124 wxPyEndAllowThreads(__tstate);
19125 if (PyErr_Occurred()) SWIG_fail;
19126 }
19127 resultobj = SWIG_Py_Void();
19128 return resultobj;
19129 fail:
19130 return NULL;
19131 }
19132
19133
19134 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19135 PyObject *resultobj = 0;
19136 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19137 long result;
19138 void *argp1 = 0 ;
19139 int res1 = 0 ;
19140 PyObject *swig_obj[1] ;
19141
19142 if (!args) SWIG_fail;
19143 swig_obj[0] = args;
19144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19145 if (!SWIG_IsOK(res1)) {
19146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19147 }
19148 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19149 {
19150 PyThreadState* __tstate = wxPyBeginAllowThreads();
19151 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 resultobj = SWIG_From_long(static_cast< long >(result));
19156 return resultobj;
19157 fail:
19158 return NULL;
19159 }
19160
19161
19162 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19163 PyObject *resultobj = 0;
19164 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19165 int arg2 ;
19166 void *argp1 = 0 ;
19167 int res1 = 0 ;
19168 int val2 ;
19169 int ecode2 = 0 ;
19170 PyObject * obj0 = 0 ;
19171 PyObject * obj1 = 0 ;
19172 char * kwnames[] = {
19173 (char *) "self",(char *) "i", NULL
19174 };
19175
19176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19178 if (!SWIG_IsOK(res1)) {
19179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19180 }
19181 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19182 ecode2 = SWIG_AsVal_int(obj1, &val2);
19183 if (!SWIG_IsOK(ecode2)) {
19184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19185 }
19186 arg2 = static_cast< int >(val2);
19187 {
19188 PyThreadState* __tstate = wxPyBeginAllowThreads();
19189 (arg1)->SetInt(arg2);
19190 wxPyEndAllowThreads(__tstate);
19191 if (PyErr_Occurred()) SWIG_fail;
19192 }
19193 resultobj = SWIG_Py_Void();
19194 return resultobj;
19195 fail:
19196 return NULL;
19197 }
19198
19199
19200 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19201 PyObject *resultobj = 0;
19202 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19203 int result;
19204 void *argp1 = 0 ;
19205 int res1 = 0 ;
19206 PyObject *swig_obj[1] ;
19207
19208 if (!args) SWIG_fail;
19209 swig_obj[0] = args;
19210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19211 if (!SWIG_IsOK(res1)) {
19212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19213 }
19214 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19215 {
19216 PyThreadState* __tstate = wxPyBeginAllowThreads();
19217 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19218 wxPyEndAllowThreads(__tstate);
19219 if (PyErr_Occurred()) SWIG_fail;
19220 }
19221 resultobj = SWIG_From_int(static_cast< int >(result));
19222 return resultobj;
19223 fail:
19224 return NULL;
19225 }
19226
19227
19228 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19229 PyObject *resultobj = 0;
19230 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19231 PyObject *result = 0 ;
19232 void *argp1 = 0 ;
19233 int res1 = 0 ;
19234 PyObject *swig_obj[1] ;
19235
19236 if (!args) SWIG_fail;
19237 swig_obj[0] = args;
19238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19239 if (!SWIG_IsOK(res1)) {
19240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19241 }
19242 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19243 {
19244 PyThreadState* __tstate = wxPyBeginAllowThreads();
19245 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19246 wxPyEndAllowThreads(__tstate);
19247 if (PyErr_Occurred()) SWIG_fail;
19248 }
19249 resultobj = result;
19250 return resultobj;
19251 fail:
19252 return NULL;
19253 }
19254
19255
19256 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19257 PyObject *resultobj = 0;
19258 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19259 PyObject *arg2 = (PyObject *) 0 ;
19260 void *argp1 = 0 ;
19261 int res1 = 0 ;
19262 PyObject * obj0 = 0 ;
19263 PyObject * obj1 = 0 ;
19264 char * kwnames[] = {
19265 (char *) "self",(char *) "clientData", NULL
19266 };
19267
19268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19270 if (!SWIG_IsOK(res1)) {
19271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19272 }
19273 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19274 arg2 = obj1;
19275 {
19276 PyThreadState* __tstate = wxPyBeginAllowThreads();
19277 wxCommandEvent_SetClientData(arg1,arg2);
19278 wxPyEndAllowThreads(__tstate);
19279 if (PyErr_Occurred()) SWIG_fail;
19280 }
19281 resultobj = SWIG_Py_Void();
19282 return resultobj;
19283 fail:
19284 return NULL;
19285 }
19286
19287
19288 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19289 PyObject *resultobj = 0;
19290 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19291 wxEvent *result = 0 ;
19292 void *argp1 = 0 ;
19293 int res1 = 0 ;
19294 PyObject *swig_obj[1] ;
19295
19296 if (!args) SWIG_fail;
19297 swig_obj[0] = args;
19298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19299 if (!SWIG_IsOK(res1)) {
19300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19301 }
19302 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19303 {
19304 PyThreadState* __tstate = wxPyBeginAllowThreads();
19305 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19306 wxPyEndAllowThreads(__tstate);
19307 if (PyErr_Occurred()) SWIG_fail;
19308 }
19309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19310 return resultobj;
19311 fail:
19312 return NULL;
19313 }
19314
19315
19316 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19317 PyObject *obj;
19318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19319 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19320 return SWIG_Py_Void();
19321 }
19322
19323 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19324 return SWIG_Python_InitShadowInstance(args);
19325 }
19326
19327 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19328 PyObject *resultobj = 0;
19329 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19330 int arg2 = (int) 0 ;
19331 wxNotifyEvent *result = 0 ;
19332 int val1 ;
19333 int ecode1 = 0 ;
19334 int val2 ;
19335 int ecode2 = 0 ;
19336 PyObject * obj0 = 0 ;
19337 PyObject * obj1 = 0 ;
19338 char * kwnames[] = {
19339 (char *) "commandType",(char *) "winid", NULL
19340 };
19341
19342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19343 if (obj0) {
19344 ecode1 = SWIG_AsVal_int(obj0, &val1);
19345 if (!SWIG_IsOK(ecode1)) {
19346 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19347 }
19348 arg1 = static_cast< wxEventType >(val1);
19349 }
19350 if (obj1) {
19351 ecode2 = SWIG_AsVal_int(obj1, &val2);
19352 if (!SWIG_IsOK(ecode2)) {
19353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19354 }
19355 arg2 = static_cast< int >(val2);
19356 }
19357 {
19358 PyThreadState* __tstate = wxPyBeginAllowThreads();
19359 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19360 wxPyEndAllowThreads(__tstate);
19361 if (PyErr_Occurred()) SWIG_fail;
19362 }
19363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19364 return resultobj;
19365 fail:
19366 return NULL;
19367 }
19368
19369
19370 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19371 PyObject *resultobj = 0;
19372 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19373 void *argp1 = 0 ;
19374 int res1 = 0 ;
19375 PyObject *swig_obj[1] ;
19376
19377 if (!args) SWIG_fail;
19378 swig_obj[0] = args;
19379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19380 if (!SWIG_IsOK(res1)) {
19381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19382 }
19383 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19384 {
19385 PyThreadState* __tstate = wxPyBeginAllowThreads();
19386 (arg1)->Veto();
19387 wxPyEndAllowThreads(__tstate);
19388 if (PyErr_Occurred()) SWIG_fail;
19389 }
19390 resultobj = SWIG_Py_Void();
19391 return resultobj;
19392 fail:
19393 return NULL;
19394 }
19395
19396
19397 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19398 PyObject *resultobj = 0;
19399 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19400 void *argp1 = 0 ;
19401 int res1 = 0 ;
19402 PyObject *swig_obj[1] ;
19403
19404 if (!args) SWIG_fail;
19405 swig_obj[0] = args;
19406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19407 if (!SWIG_IsOK(res1)) {
19408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19409 }
19410 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19411 {
19412 PyThreadState* __tstate = wxPyBeginAllowThreads();
19413 (arg1)->Allow();
19414 wxPyEndAllowThreads(__tstate);
19415 if (PyErr_Occurred()) SWIG_fail;
19416 }
19417 resultobj = SWIG_Py_Void();
19418 return resultobj;
19419 fail:
19420 return NULL;
19421 }
19422
19423
19424 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19425 PyObject *resultobj = 0;
19426 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19427 bool result;
19428 void *argp1 = 0 ;
19429 int res1 = 0 ;
19430 PyObject *swig_obj[1] ;
19431
19432 if (!args) SWIG_fail;
19433 swig_obj[0] = args;
19434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19435 if (!SWIG_IsOK(res1)) {
19436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19437 }
19438 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19439 {
19440 PyThreadState* __tstate = wxPyBeginAllowThreads();
19441 result = (bool)(arg1)->IsAllowed();
19442 wxPyEndAllowThreads(__tstate);
19443 if (PyErr_Occurred()) SWIG_fail;
19444 }
19445 {
19446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19447 }
19448 return resultobj;
19449 fail:
19450 return NULL;
19451 }
19452
19453
19454 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19455 PyObject *obj;
19456 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19457 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19458 return SWIG_Py_Void();
19459 }
19460
19461 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19462 return SWIG_Python_InitShadowInstance(args);
19463 }
19464
19465 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19466 PyObject *resultobj = 0;
19467 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19468 int arg2 = (int) 0 ;
19469 int arg3 = (int) 0 ;
19470 int arg4 = (int) 0 ;
19471 wxScrollEvent *result = 0 ;
19472 int val1 ;
19473 int ecode1 = 0 ;
19474 int val2 ;
19475 int ecode2 = 0 ;
19476 int val3 ;
19477 int ecode3 = 0 ;
19478 int val4 ;
19479 int ecode4 = 0 ;
19480 PyObject * obj0 = 0 ;
19481 PyObject * obj1 = 0 ;
19482 PyObject * obj2 = 0 ;
19483 PyObject * obj3 = 0 ;
19484 char * kwnames[] = {
19485 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19486 };
19487
19488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19489 if (obj0) {
19490 ecode1 = SWIG_AsVal_int(obj0, &val1);
19491 if (!SWIG_IsOK(ecode1)) {
19492 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19493 }
19494 arg1 = static_cast< wxEventType >(val1);
19495 }
19496 if (obj1) {
19497 ecode2 = SWIG_AsVal_int(obj1, &val2);
19498 if (!SWIG_IsOK(ecode2)) {
19499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19500 }
19501 arg2 = static_cast< int >(val2);
19502 }
19503 if (obj2) {
19504 ecode3 = SWIG_AsVal_int(obj2, &val3);
19505 if (!SWIG_IsOK(ecode3)) {
19506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19507 }
19508 arg3 = static_cast< int >(val3);
19509 }
19510 if (obj3) {
19511 ecode4 = SWIG_AsVal_int(obj3, &val4);
19512 if (!SWIG_IsOK(ecode4)) {
19513 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19514 }
19515 arg4 = static_cast< int >(val4);
19516 }
19517 {
19518 PyThreadState* __tstate = wxPyBeginAllowThreads();
19519 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19520 wxPyEndAllowThreads(__tstate);
19521 if (PyErr_Occurred()) SWIG_fail;
19522 }
19523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19524 return resultobj;
19525 fail:
19526 return NULL;
19527 }
19528
19529
19530 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19531 PyObject *resultobj = 0;
19532 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19533 int result;
19534 void *argp1 = 0 ;
19535 int res1 = 0 ;
19536 PyObject *swig_obj[1] ;
19537
19538 if (!args) SWIG_fail;
19539 swig_obj[0] = args;
19540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19541 if (!SWIG_IsOK(res1)) {
19542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19543 }
19544 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19545 {
19546 PyThreadState* __tstate = wxPyBeginAllowThreads();
19547 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19548 wxPyEndAllowThreads(__tstate);
19549 if (PyErr_Occurred()) SWIG_fail;
19550 }
19551 resultobj = SWIG_From_int(static_cast< int >(result));
19552 return resultobj;
19553 fail:
19554 return NULL;
19555 }
19556
19557
19558 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19559 PyObject *resultobj = 0;
19560 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19561 int result;
19562 void *argp1 = 0 ;
19563 int res1 = 0 ;
19564 PyObject *swig_obj[1] ;
19565
19566 if (!args) SWIG_fail;
19567 swig_obj[0] = args;
19568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19569 if (!SWIG_IsOK(res1)) {
19570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19571 }
19572 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19573 {
19574 PyThreadState* __tstate = wxPyBeginAllowThreads();
19575 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19576 wxPyEndAllowThreads(__tstate);
19577 if (PyErr_Occurred()) SWIG_fail;
19578 }
19579 resultobj = SWIG_From_int(static_cast< int >(result));
19580 return resultobj;
19581 fail:
19582 return NULL;
19583 }
19584
19585
19586 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19587 PyObject *resultobj = 0;
19588 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19589 int arg2 ;
19590 void *argp1 = 0 ;
19591 int res1 = 0 ;
19592 int val2 ;
19593 int ecode2 = 0 ;
19594 PyObject * obj0 = 0 ;
19595 PyObject * obj1 = 0 ;
19596 char * kwnames[] = {
19597 (char *) "self",(char *) "orient", NULL
19598 };
19599
19600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19602 if (!SWIG_IsOK(res1)) {
19603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19604 }
19605 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19606 ecode2 = SWIG_AsVal_int(obj1, &val2);
19607 if (!SWIG_IsOK(ecode2)) {
19608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19609 }
19610 arg2 = static_cast< int >(val2);
19611 {
19612 PyThreadState* __tstate = wxPyBeginAllowThreads();
19613 (arg1)->SetOrientation(arg2);
19614 wxPyEndAllowThreads(__tstate);
19615 if (PyErr_Occurred()) SWIG_fail;
19616 }
19617 resultobj = SWIG_Py_Void();
19618 return resultobj;
19619 fail:
19620 return NULL;
19621 }
19622
19623
19624 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19625 PyObject *resultobj = 0;
19626 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19627 int arg2 ;
19628 void *argp1 = 0 ;
19629 int res1 = 0 ;
19630 int val2 ;
19631 int ecode2 = 0 ;
19632 PyObject * obj0 = 0 ;
19633 PyObject * obj1 = 0 ;
19634 char * kwnames[] = {
19635 (char *) "self",(char *) "pos", NULL
19636 };
19637
19638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19640 if (!SWIG_IsOK(res1)) {
19641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19642 }
19643 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19644 ecode2 = SWIG_AsVal_int(obj1, &val2);
19645 if (!SWIG_IsOK(ecode2)) {
19646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19647 }
19648 arg2 = static_cast< int >(val2);
19649 {
19650 PyThreadState* __tstate = wxPyBeginAllowThreads();
19651 (arg1)->SetPosition(arg2);
19652 wxPyEndAllowThreads(__tstate);
19653 if (PyErr_Occurred()) SWIG_fail;
19654 }
19655 resultobj = SWIG_Py_Void();
19656 return resultobj;
19657 fail:
19658 return NULL;
19659 }
19660
19661
19662 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19663 PyObject *obj;
19664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19665 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19666 return SWIG_Py_Void();
19667 }
19668
19669 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19670 return SWIG_Python_InitShadowInstance(args);
19671 }
19672
19673 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19674 PyObject *resultobj = 0;
19675 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19676 int arg2 = (int) 0 ;
19677 int arg3 = (int) 0 ;
19678 wxScrollWinEvent *result = 0 ;
19679 int val1 ;
19680 int ecode1 = 0 ;
19681 int val2 ;
19682 int ecode2 = 0 ;
19683 int val3 ;
19684 int ecode3 = 0 ;
19685 PyObject * obj0 = 0 ;
19686 PyObject * obj1 = 0 ;
19687 PyObject * obj2 = 0 ;
19688 char * kwnames[] = {
19689 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19690 };
19691
19692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19693 if (obj0) {
19694 ecode1 = SWIG_AsVal_int(obj0, &val1);
19695 if (!SWIG_IsOK(ecode1)) {
19696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19697 }
19698 arg1 = static_cast< wxEventType >(val1);
19699 }
19700 if (obj1) {
19701 ecode2 = SWIG_AsVal_int(obj1, &val2);
19702 if (!SWIG_IsOK(ecode2)) {
19703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19704 }
19705 arg2 = static_cast< int >(val2);
19706 }
19707 if (obj2) {
19708 ecode3 = SWIG_AsVal_int(obj2, &val3);
19709 if (!SWIG_IsOK(ecode3)) {
19710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19711 }
19712 arg3 = static_cast< int >(val3);
19713 }
19714 {
19715 PyThreadState* __tstate = wxPyBeginAllowThreads();
19716 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19717 wxPyEndAllowThreads(__tstate);
19718 if (PyErr_Occurred()) SWIG_fail;
19719 }
19720 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19721 return resultobj;
19722 fail:
19723 return NULL;
19724 }
19725
19726
19727 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19728 PyObject *resultobj = 0;
19729 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19730 int result;
19731 void *argp1 = 0 ;
19732 int res1 = 0 ;
19733 PyObject *swig_obj[1] ;
19734
19735 if (!args) SWIG_fail;
19736 swig_obj[0] = args;
19737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19738 if (!SWIG_IsOK(res1)) {
19739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19740 }
19741 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19742 {
19743 PyThreadState* __tstate = wxPyBeginAllowThreads();
19744 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19745 wxPyEndAllowThreads(__tstate);
19746 if (PyErr_Occurred()) SWIG_fail;
19747 }
19748 resultobj = SWIG_From_int(static_cast< int >(result));
19749 return resultobj;
19750 fail:
19751 return NULL;
19752 }
19753
19754
19755 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19756 PyObject *resultobj = 0;
19757 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19758 int result;
19759 void *argp1 = 0 ;
19760 int res1 = 0 ;
19761 PyObject *swig_obj[1] ;
19762
19763 if (!args) SWIG_fail;
19764 swig_obj[0] = args;
19765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19766 if (!SWIG_IsOK(res1)) {
19767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19768 }
19769 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19770 {
19771 PyThreadState* __tstate = wxPyBeginAllowThreads();
19772 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19773 wxPyEndAllowThreads(__tstate);
19774 if (PyErr_Occurred()) SWIG_fail;
19775 }
19776 resultobj = SWIG_From_int(static_cast< int >(result));
19777 return resultobj;
19778 fail:
19779 return NULL;
19780 }
19781
19782
19783 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19784 PyObject *resultobj = 0;
19785 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19786 int arg2 ;
19787 void *argp1 = 0 ;
19788 int res1 = 0 ;
19789 int val2 ;
19790 int ecode2 = 0 ;
19791 PyObject * obj0 = 0 ;
19792 PyObject * obj1 = 0 ;
19793 char * kwnames[] = {
19794 (char *) "self",(char *) "orient", NULL
19795 };
19796
19797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19799 if (!SWIG_IsOK(res1)) {
19800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19801 }
19802 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19803 ecode2 = SWIG_AsVal_int(obj1, &val2);
19804 if (!SWIG_IsOK(ecode2)) {
19805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19806 }
19807 arg2 = static_cast< int >(val2);
19808 {
19809 PyThreadState* __tstate = wxPyBeginAllowThreads();
19810 (arg1)->SetOrientation(arg2);
19811 wxPyEndAllowThreads(__tstate);
19812 if (PyErr_Occurred()) SWIG_fail;
19813 }
19814 resultobj = SWIG_Py_Void();
19815 return resultobj;
19816 fail:
19817 return NULL;
19818 }
19819
19820
19821 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19822 PyObject *resultobj = 0;
19823 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19824 int arg2 ;
19825 void *argp1 = 0 ;
19826 int res1 = 0 ;
19827 int val2 ;
19828 int ecode2 = 0 ;
19829 PyObject * obj0 = 0 ;
19830 PyObject * obj1 = 0 ;
19831 char * kwnames[] = {
19832 (char *) "self",(char *) "pos", NULL
19833 };
19834
19835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19837 if (!SWIG_IsOK(res1)) {
19838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19839 }
19840 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19841 ecode2 = SWIG_AsVal_int(obj1, &val2);
19842 if (!SWIG_IsOK(ecode2)) {
19843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19844 }
19845 arg2 = static_cast< int >(val2);
19846 {
19847 PyThreadState* __tstate = wxPyBeginAllowThreads();
19848 (arg1)->SetPosition(arg2);
19849 wxPyEndAllowThreads(__tstate);
19850 if (PyErr_Occurred()) SWIG_fail;
19851 }
19852 resultobj = SWIG_Py_Void();
19853 return resultobj;
19854 fail:
19855 return NULL;
19856 }
19857
19858
19859 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19860 PyObject *obj;
19861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19862 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19863 return SWIG_Py_Void();
19864 }
19865
19866 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19867 return SWIG_Python_InitShadowInstance(args);
19868 }
19869
19870 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19871 PyObject *resultobj = 0;
19872 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19873 wxMouseEvent *result = 0 ;
19874 int val1 ;
19875 int ecode1 = 0 ;
19876 PyObject * obj0 = 0 ;
19877 char * kwnames[] = {
19878 (char *) "mouseType", NULL
19879 };
19880
19881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19882 if (obj0) {
19883 ecode1 = SWIG_AsVal_int(obj0, &val1);
19884 if (!SWIG_IsOK(ecode1)) {
19885 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19886 }
19887 arg1 = static_cast< wxEventType >(val1);
19888 }
19889 {
19890 PyThreadState* __tstate = wxPyBeginAllowThreads();
19891 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19892 wxPyEndAllowThreads(__tstate);
19893 if (PyErr_Occurred()) SWIG_fail;
19894 }
19895 {
19896 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19897 }
19898 return resultobj;
19899 fail:
19900 return NULL;
19901 }
19902
19903
19904 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19905 PyObject *resultobj = 0;
19906 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19907 bool result;
19908 void *argp1 = 0 ;
19909 int res1 = 0 ;
19910 PyObject *swig_obj[1] ;
19911
19912 if (!args) SWIG_fail;
19913 swig_obj[0] = args;
19914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19915 if (!SWIG_IsOK(res1)) {
19916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19917 }
19918 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19919 {
19920 PyThreadState* __tstate = wxPyBeginAllowThreads();
19921 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19922 wxPyEndAllowThreads(__tstate);
19923 if (PyErr_Occurred()) SWIG_fail;
19924 }
19925 {
19926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19927 }
19928 return resultobj;
19929 fail:
19930 return NULL;
19931 }
19932
19933
19934 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19935 PyObject *resultobj = 0;
19936 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19937 int arg2 = (int) wxMOUSE_BTN_ANY ;
19938 bool result;
19939 void *argp1 = 0 ;
19940 int res1 = 0 ;
19941 int val2 ;
19942 int ecode2 = 0 ;
19943 PyObject * obj0 = 0 ;
19944 PyObject * obj1 = 0 ;
19945 char * kwnames[] = {
19946 (char *) "self",(char *) "but", NULL
19947 };
19948
19949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19951 if (!SWIG_IsOK(res1)) {
19952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19953 }
19954 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19955 if (obj1) {
19956 ecode2 = SWIG_AsVal_int(obj1, &val2);
19957 if (!SWIG_IsOK(ecode2)) {
19958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19959 }
19960 arg2 = static_cast< int >(val2);
19961 }
19962 {
19963 PyThreadState* __tstate = wxPyBeginAllowThreads();
19964 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19965 wxPyEndAllowThreads(__tstate);
19966 if (PyErr_Occurred()) SWIG_fail;
19967 }
19968 {
19969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19970 }
19971 return resultobj;
19972 fail:
19973 return NULL;
19974 }
19975
19976
19977 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19978 PyObject *resultobj = 0;
19979 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19980 int arg2 = (int) wxMOUSE_BTN_ANY ;
19981 bool result;
19982 void *argp1 = 0 ;
19983 int res1 = 0 ;
19984 int val2 ;
19985 int ecode2 = 0 ;
19986 PyObject * obj0 = 0 ;
19987 PyObject * obj1 = 0 ;
19988 char * kwnames[] = {
19989 (char *) "self",(char *) "but", NULL
19990 };
19991
19992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19994 if (!SWIG_IsOK(res1)) {
19995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19996 }
19997 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19998 if (obj1) {
19999 ecode2 = SWIG_AsVal_int(obj1, &val2);
20000 if (!SWIG_IsOK(ecode2)) {
20001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20002 }
20003 arg2 = static_cast< int >(val2);
20004 }
20005 {
20006 PyThreadState* __tstate = wxPyBeginAllowThreads();
20007 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20008 wxPyEndAllowThreads(__tstate);
20009 if (PyErr_Occurred()) SWIG_fail;
20010 }
20011 {
20012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20013 }
20014 return resultobj;
20015 fail:
20016 return NULL;
20017 }
20018
20019
20020 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20021 PyObject *resultobj = 0;
20022 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20023 int arg2 = (int) wxMOUSE_BTN_ANY ;
20024 bool result;
20025 void *argp1 = 0 ;
20026 int res1 = 0 ;
20027 int val2 ;
20028 int ecode2 = 0 ;
20029 PyObject * obj0 = 0 ;
20030 PyObject * obj1 = 0 ;
20031 char * kwnames[] = {
20032 (char *) "self",(char *) "but", NULL
20033 };
20034
20035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20037 if (!SWIG_IsOK(res1)) {
20038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20039 }
20040 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20041 if (obj1) {
20042 ecode2 = SWIG_AsVal_int(obj1, &val2);
20043 if (!SWIG_IsOK(ecode2)) {
20044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20045 }
20046 arg2 = static_cast< int >(val2);
20047 }
20048 {
20049 PyThreadState* __tstate = wxPyBeginAllowThreads();
20050 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20051 wxPyEndAllowThreads(__tstate);
20052 if (PyErr_Occurred()) SWIG_fail;
20053 }
20054 {
20055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20056 }
20057 return resultobj;
20058 fail:
20059 return NULL;
20060 }
20061
20062
20063 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20064 PyObject *resultobj = 0;
20065 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20066 int arg2 ;
20067 bool result;
20068 void *argp1 = 0 ;
20069 int res1 = 0 ;
20070 int val2 ;
20071 int ecode2 = 0 ;
20072 PyObject * obj0 = 0 ;
20073 PyObject * obj1 = 0 ;
20074 char * kwnames[] = {
20075 (char *) "self",(char *) "button", NULL
20076 };
20077
20078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20080 if (!SWIG_IsOK(res1)) {
20081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20082 }
20083 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20084 ecode2 = SWIG_AsVal_int(obj1, &val2);
20085 if (!SWIG_IsOK(ecode2)) {
20086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20087 }
20088 arg2 = static_cast< int >(val2);
20089 {
20090 PyThreadState* __tstate = wxPyBeginAllowThreads();
20091 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20092 wxPyEndAllowThreads(__tstate);
20093 if (PyErr_Occurred()) SWIG_fail;
20094 }
20095 {
20096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20097 }
20098 return resultobj;
20099 fail:
20100 return NULL;
20101 }
20102
20103
20104 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20105 PyObject *resultobj = 0;
20106 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20107 int arg2 ;
20108 bool result;
20109 void *argp1 = 0 ;
20110 int res1 = 0 ;
20111 int val2 ;
20112 int ecode2 = 0 ;
20113 PyObject * obj0 = 0 ;
20114 PyObject * obj1 = 0 ;
20115 char * kwnames[] = {
20116 (char *) "self",(char *) "but", NULL
20117 };
20118
20119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20121 if (!SWIG_IsOK(res1)) {
20122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20123 }
20124 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20125 ecode2 = SWIG_AsVal_int(obj1, &val2);
20126 if (!SWIG_IsOK(ecode2)) {
20127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20128 }
20129 arg2 = static_cast< int >(val2);
20130 {
20131 PyThreadState* __tstate = wxPyBeginAllowThreads();
20132 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20133 wxPyEndAllowThreads(__tstate);
20134 if (PyErr_Occurred()) SWIG_fail;
20135 }
20136 {
20137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20138 }
20139 return resultobj;
20140 fail:
20141 return NULL;
20142 }
20143
20144
20145 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20146 PyObject *resultobj = 0;
20147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20148 int result;
20149 void *argp1 = 0 ;
20150 int res1 = 0 ;
20151 PyObject *swig_obj[1] ;
20152
20153 if (!args) SWIG_fail;
20154 swig_obj[0] = args;
20155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20156 if (!SWIG_IsOK(res1)) {
20157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20158 }
20159 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20160 {
20161 PyThreadState* __tstate = wxPyBeginAllowThreads();
20162 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20163 wxPyEndAllowThreads(__tstate);
20164 if (PyErr_Occurred()) SWIG_fail;
20165 }
20166 resultobj = SWIG_From_int(static_cast< int >(result));
20167 return resultobj;
20168 fail:
20169 return NULL;
20170 }
20171
20172
20173 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20174 PyObject *resultobj = 0;
20175 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20176 bool result;
20177 void *argp1 = 0 ;
20178 int res1 = 0 ;
20179 PyObject *swig_obj[1] ;
20180
20181 if (!args) SWIG_fail;
20182 swig_obj[0] = args;
20183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20184 if (!SWIG_IsOK(res1)) {
20185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20186 }
20187 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20188 {
20189 PyThreadState* __tstate = wxPyBeginAllowThreads();
20190 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20191 wxPyEndAllowThreads(__tstate);
20192 if (PyErr_Occurred()) SWIG_fail;
20193 }
20194 {
20195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20196 }
20197 return resultobj;
20198 fail:
20199 return NULL;
20200 }
20201
20202
20203 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20204 PyObject *resultobj = 0;
20205 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20206 bool result;
20207 void *argp1 = 0 ;
20208 int res1 = 0 ;
20209 PyObject *swig_obj[1] ;
20210
20211 if (!args) SWIG_fail;
20212 swig_obj[0] = args;
20213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20214 if (!SWIG_IsOK(res1)) {
20215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20216 }
20217 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20218 {
20219 PyThreadState* __tstate = wxPyBeginAllowThreads();
20220 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20221 wxPyEndAllowThreads(__tstate);
20222 if (PyErr_Occurred()) SWIG_fail;
20223 }
20224 {
20225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20226 }
20227 return resultobj;
20228 fail:
20229 return NULL;
20230 }
20231
20232
20233 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20234 PyObject *resultobj = 0;
20235 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20236 bool result;
20237 void *argp1 = 0 ;
20238 int res1 = 0 ;
20239 PyObject *swig_obj[1] ;
20240
20241 if (!args) SWIG_fail;
20242 swig_obj[0] = args;
20243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20244 if (!SWIG_IsOK(res1)) {
20245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20246 }
20247 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20248 {
20249 PyThreadState* __tstate = wxPyBeginAllowThreads();
20250 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20251 wxPyEndAllowThreads(__tstate);
20252 if (PyErr_Occurred()) SWIG_fail;
20253 }
20254 {
20255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20256 }
20257 return resultobj;
20258 fail:
20259 return NULL;
20260 }
20261
20262
20263 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20264 PyObject *resultobj = 0;
20265 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20266 bool result;
20267 void *argp1 = 0 ;
20268 int res1 = 0 ;
20269 PyObject *swig_obj[1] ;
20270
20271 if (!args) SWIG_fail;
20272 swig_obj[0] = args;
20273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20274 if (!SWIG_IsOK(res1)) {
20275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20276 }
20277 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20278 {
20279 PyThreadState* __tstate = wxPyBeginAllowThreads();
20280 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20281 wxPyEndAllowThreads(__tstate);
20282 if (PyErr_Occurred()) SWIG_fail;
20283 }
20284 {
20285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20286 }
20287 return resultobj;
20288 fail:
20289 return NULL;
20290 }
20291
20292
20293 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20294 PyObject *resultobj = 0;
20295 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20296 bool result;
20297 void *argp1 = 0 ;
20298 int res1 = 0 ;
20299 PyObject *swig_obj[1] ;
20300
20301 if (!args) SWIG_fail;
20302 swig_obj[0] = args;
20303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20304 if (!SWIG_IsOK(res1)) {
20305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20306 }
20307 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20308 {
20309 PyThreadState* __tstate = wxPyBeginAllowThreads();
20310 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20311 wxPyEndAllowThreads(__tstate);
20312 if (PyErr_Occurred()) SWIG_fail;
20313 }
20314 {
20315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20316 }
20317 return resultobj;
20318 fail:
20319 return NULL;
20320 }
20321
20322
20323 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20324 PyObject *resultobj = 0;
20325 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20326 bool result;
20327 void *argp1 = 0 ;
20328 int res1 = 0 ;
20329 PyObject *swig_obj[1] ;
20330
20331 if (!args) SWIG_fail;
20332 swig_obj[0] = args;
20333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20334 if (!SWIG_IsOK(res1)) {
20335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20336 }
20337 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20338 {
20339 PyThreadState* __tstate = wxPyBeginAllowThreads();
20340 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20341 wxPyEndAllowThreads(__tstate);
20342 if (PyErr_Occurred()) SWIG_fail;
20343 }
20344 {
20345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20346 }
20347 return resultobj;
20348 fail:
20349 return NULL;
20350 }
20351
20352
20353 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20354 PyObject *resultobj = 0;
20355 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20356 bool result;
20357 void *argp1 = 0 ;
20358 int res1 = 0 ;
20359 PyObject *swig_obj[1] ;
20360
20361 if (!args) SWIG_fail;
20362 swig_obj[0] = args;
20363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20364 if (!SWIG_IsOK(res1)) {
20365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20366 }
20367 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20368 {
20369 PyThreadState* __tstate = wxPyBeginAllowThreads();
20370 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20371 wxPyEndAllowThreads(__tstate);
20372 if (PyErr_Occurred()) SWIG_fail;
20373 }
20374 {
20375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20376 }
20377 return resultobj;
20378 fail:
20379 return NULL;
20380 }
20381
20382
20383 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20384 PyObject *resultobj = 0;
20385 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20386 bool result;
20387 void *argp1 = 0 ;
20388 int res1 = 0 ;
20389 PyObject *swig_obj[1] ;
20390
20391 if (!args) SWIG_fail;
20392 swig_obj[0] = args;
20393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20394 if (!SWIG_IsOK(res1)) {
20395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20396 }
20397 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20398 {
20399 PyThreadState* __tstate = wxPyBeginAllowThreads();
20400 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20401 wxPyEndAllowThreads(__tstate);
20402 if (PyErr_Occurred()) SWIG_fail;
20403 }
20404 {
20405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20406 }
20407 return resultobj;
20408 fail:
20409 return NULL;
20410 }
20411
20412
20413 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20414 PyObject *resultobj = 0;
20415 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20416 bool result;
20417 void *argp1 = 0 ;
20418 int res1 = 0 ;
20419 PyObject *swig_obj[1] ;
20420
20421 if (!args) SWIG_fail;
20422 swig_obj[0] = args;
20423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20424 if (!SWIG_IsOK(res1)) {
20425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20426 }
20427 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20428 {
20429 PyThreadState* __tstate = wxPyBeginAllowThreads();
20430 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20431 wxPyEndAllowThreads(__tstate);
20432 if (PyErr_Occurred()) SWIG_fail;
20433 }
20434 {
20435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20436 }
20437 return resultobj;
20438 fail:
20439 return NULL;
20440 }
20441
20442
20443 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20444 PyObject *resultobj = 0;
20445 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20446 bool result;
20447 void *argp1 = 0 ;
20448 int res1 = 0 ;
20449 PyObject *swig_obj[1] ;
20450
20451 if (!args) SWIG_fail;
20452 swig_obj[0] = args;
20453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20454 if (!SWIG_IsOK(res1)) {
20455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20456 }
20457 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20458 {
20459 PyThreadState* __tstate = wxPyBeginAllowThreads();
20460 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20461 wxPyEndAllowThreads(__tstate);
20462 if (PyErr_Occurred()) SWIG_fail;
20463 }
20464 {
20465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20466 }
20467 return resultobj;
20468 fail:
20469 return NULL;
20470 }
20471
20472
20473 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20474 PyObject *resultobj = 0;
20475 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20476 bool result;
20477 void *argp1 = 0 ;
20478 int res1 = 0 ;
20479 PyObject *swig_obj[1] ;
20480
20481 if (!args) SWIG_fail;
20482 swig_obj[0] = args;
20483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20484 if (!SWIG_IsOK(res1)) {
20485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20486 }
20487 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20488 {
20489 PyThreadState* __tstate = wxPyBeginAllowThreads();
20490 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20491 wxPyEndAllowThreads(__tstate);
20492 if (PyErr_Occurred()) SWIG_fail;
20493 }
20494 {
20495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20496 }
20497 return resultobj;
20498 fail:
20499 return NULL;
20500 }
20501
20502
20503 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20504 PyObject *resultobj = 0;
20505 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20506 bool result;
20507 void *argp1 = 0 ;
20508 int res1 = 0 ;
20509 PyObject *swig_obj[1] ;
20510
20511 if (!args) SWIG_fail;
20512 swig_obj[0] = args;
20513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20514 if (!SWIG_IsOK(res1)) {
20515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20516 }
20517 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20518 {
20519 PyThreadState* __tstate = wxPyBeginAllowThreads();
20520 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20521 wxPyEndAllowThreads(__tstate);
20522 if (PyErr_Occurred()) SWIG_fail;
20523 }
20524 {
20525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20526 }
20527 return resultobj;
20528 fail:
20529 return NULL;
20530 }
20531
20532
20533 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20534 PyObject *resultobj = 0;
20535 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20536 bool result;
20537 void *argp1 = 0 ;
20538 int res1 = 0 ;
20539 PyObject *swig_obj[1] ;
20540
20541 if (!args) SWIG_fail;
20542 swig_obj[0] = args;
20543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20544 if (!SWIG_IsOK(res1)) {
20545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20546 }
20547 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20548 {
20549 PyThreadState* __tstate = wxPyBeginAllowThreads();
20550 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20551 wxPyEndAllowThreads(__tstate);
20552 if (PyErr_Occurred()) SWIG_fail;
20553 }
20554 {
20555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20556 }
20557 return resultobj;
20558 fail:
20559 return NULL;
20560 }
20561
20562
20563 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20564 PyObject *resultobj = 0;
20565 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20566 bool result;
20567 void *argp1 = 0 ;
20568 int res1 = 0 ;
20569 PyObject *swig_obj[1] ;
20570
20571 if (!args) SWIG_fail;
20572 swig_obj[0] = args;
20573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20574 if (!SWIG_IsOK(res1)) {
20575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20576 }
20577 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20578 {
20579 PyThreadState* __tstate = wxPyBeginAllowThreads();
20580 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20581 wxPyEndAllowThreads(__tstate);
20582 if (PyErr_Occurred()) SWIG_fail;
20583 }
20584 {
20585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20586 }
20587 return resultobj;
20588 fail:
20589 return NULL;
20590 }
20591
20592
20593 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20594 PyObject *resultobj = 0;
20595 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20596 bool result;
20597 void *argp1 = 0 ;
20598 int res1 = 0 ;
20599 PyObject *swig_obj[1] ;
20600
20601 if (!args) SWIG_fail;
20602 swig_obj[0] = args;
20603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20604 if (!SWIG_IsOK(res1)) {
20605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20606 }
20607 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20608 {
20609 PyThreadState* __tstate = wxPyBeginAllowThreads();
20610 result = (bool)(arg1)->LeftIsDown();
20611 wxPyEndAllowThreads(__tstate);
20612 if (PyErr_Occurred()) SWIG_fail;
20613 }
20614 {
20615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20616 }
20617 return resultobj;
20618 fail:
20619 return NULL;
20620 }
20621
20622
20623 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20624 PyObject *resultobj = 0;
20625 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20626 bool result;
20627 void *argp1 = 0 ;
20628 int res1 = 0 ;
20629 PyObject *swig_obj[1] ;
20630
20631 if (!args) SWIG_fail;
20632 swig_obj[0] = args;
20633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20634 if (!SWIG_IsOK(res1)) {
20635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20636 }
20637 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20638 {
20639 PyThreadState* __tstate = wxPyBeginAllowThreads();
20640 result = (bool)(arg1)->MiddleIsDown();
20641 wxPyEndAllowThreads(__tstate);
20642 if (PyErr_Occurred()) SWIG_fail;
20643 }
20644 {
20645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20646 }
20647 return resultobj;
20648 fail:
20649 return NULL;
20650 }
20651
20652
20653 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20654 PyObject *resultobj = 0;
20655 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20656 bool result;
20657 void *argp1 = 0 ;
20658 int res1 = 0 ;
20659 PyObject *swig_obj[1] ;
20660
20661 if (!args) SWIG_fail;
20662 swig_obj[0] = args;
20663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20664 if (!SWIG_IsOK(res1)) {
20665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20666 }
20667 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20668 {
20669 PyThreadState* __tstate = wxPyBeginAllowThreads();
20670 result = (bool)(arg1)->RightIsDown();
20671 wxPyEndAllowThreads(__tstate);
20672 if (PyErr_Occurred()) SWIG_fail;
20673 }
20674 {
20675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20676 }
20677 return resultobj;
20678 fail:
20679 return NULL;
20680 }
20681
20682
20683 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20684 PyObject *resultobj = 0;
20685 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20686 bool result;
20687 void *argp1 = 0 ;
20688 int res1 = 0 ;
20689 PyObject *swig_obj[1] ;
20690
20691 if (!args) SWIG_fail;
20692 swig_obj[0] = args;
20693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20694 if (!SWIG_IsOK(res1)) {
20695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20696 }
20697 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20698 {
20699 PyThreadState* __tstate = wxPyBeginAllowThreads();
20700 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20701 wxPyEndAllowThreads(__tstate);
20702 if (PyErr_Occurred()) SWIG_fail;
20703 }
20704 {
20705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20706 }
20707 return resultobj;
20708 fail:
20709 return NULL;
20710 }
20711
20712
20713 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20714 PyObject *resultobj = 0;
20715 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20716 bool result;
20717 void *argp1 = 0 ;
20718 int res1 = 0 ;
20719 PyObject *swig_obj[1] ;
20720
20721 if (!args) SWIG_fail;
20722 swig_obj[0] = args;
20723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20724 if (!SWIG_IsOK(res1)) {
20725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20726 }
20727 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20728 {
20729 PyThreadState* __tstate = wxPyBeginAllowThreads();
20730 result = (bool)((wxMouseEvent const *)arg1)->Moving();
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_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20744 PyObject *resultobj = 0;
20745 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20746 bool result;
20747 void *argp1 = 0 ;
20748 int res1 = 0 ;
20749 PyObject *swig_obj[1] ;
20750
20751 if (!args) SWIG_fail;
20752 swig_obj[0] = args;
20753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20754 if (!SWIG_IsOK(res1)) {
20755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20756 }
20757 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20758 {
20759 PyThreadState* __tstate = wxPyBeginAllowThreads();
20760 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20761 wxPyEndAllowThreads(__tstate);
20762 if (PyErr_Occurred()) SWIG_fail;
20763 }
20764 {
20765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20766 }
20767 return resultobj;
20768 fail:
20769 return NULL;
20770 }
20771
20772
20773 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20774 PyObject *resultobj = 0;
20775 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20776 bool result;
20777 void *argp1 = 0 ;
20778 int res1 = 0 ;
20779 PyObject *swig_obj[1] ;
20780
20781 if (!args) SWIG_fail;
20782 swig_obj[0] = args;
20783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20784 if (!SWIG_IsOK(res1)) {
20785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20786 }
20787 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20788 {
20789 PyThreadState* __tstate = wxPyBeginAllowThreads();
20790 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20791 wxPyEndAllowThreads(__tstate);
20792 if (PyErr_Occurred()) SWIG_fail;
20793 }
20794 {
20795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20796 }
20797 return resultobj;
20798 fail:
20799 return NULL;
20800 }
20801
20802
20803 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20804 PyObject *resultobj = 0;
20805 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20806 wxPoint result;
20807 void *argp1 = 0 ;
20808 int res1 = 0 ;
20809 PyObject *swig_obj[1] ;
20810
20811 if (!args) SWIG_fail;
20812 swig_obj[0] = args;
20813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20814 if (!SWIG_IsOK(res1)) {
20815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20816 }
20817 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20818 {
20819 PyThreadState* __tstate = wxPyBeginAllowThreads();
20820 result = (arg1)->GetPosition();
20821 wxPyEndAllowThreads(__tstate);
20822 if (PyErr_Occurred()) SWIG_fail;
20823 }
20824 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20825 return resultobj;
20826 fail:
20827 return NULL;
20828 }
20829
20830
20831 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20832 PyObject *resultobj = 0;
20833 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20834 long *arg2 = (long *) 0 ;
20835 long *arg3 = (long *) 0 ;
20836 void *argp1 = 0 ;
20837 int res1 = 0 ;
20838 long temp2 ;
20839 int res2 = SWIG_TMPOBJ ;
20840 long temp3 ;
20841 int res3 = SWIG_TMPOBJ ;
20842 PyObject *swig_obj[1] ;
20843
20844 arg2 = &temp2;
20845 arg3 = &temp3;
20846 if (!args) SWIG_fail;
20847 swig_obj[0] = args;
20848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20849 if (!SWIG_IsOK(res1)) {
20850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20851 }
20852 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20853 {
20854 PyThreadState* __tstate = wxPyBeginAllowThreads();
20855 (arg1)->GetPosition(arg2,arg3);
20856 wxPyEndAllowThreads(__tstate);
20857 if (PyErr_Occurred()) SWIG_fail;
20858 }
20859 resultobj = SWIG_Py_Void();
20860 if (SWIG_IsTmpObj(res2)) {
20861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20862 } else {
20863 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20865 }
20866 if (SWIG_IsTmpObj(res3)) {
20867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20868 } else {
20869 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20871 }
20872 return resultobj;
20873 fail:
20874 return NULL;
20875 }
20876
20877
20878 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20879 PyObject *resultobj = 0;
20880 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20881 wxDC *arg2 = 0 ;
20882 wxPoint result;
20883 void *argp1 = 0 ;
20884 int res1 = 0 ;
20885 void *argp2 = 0 ;
20886 int res2 = 0 ;
20887 PyObject * obj0 = 0 ;
20888 PyObject * obj1 = 0 ;
20889 char * kwnames[] = {
20890 (char *) "self",(char *) "dc", NULL
20891 };
20892
20893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20895 if (!SWIG_IsOK(res1)) {
20896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20897 }
20898 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20899 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20900 if (!SWIG_IsOK(res2)) {
20901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20902 }
20903 if (!argp2) {
20904 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20905 }
20906 arg2 = reinterpret_cast< wxDC * >(argp2);
20907 {
20908 PyThreadState* __tstate = wxPyBeginAllowThreads();
20909 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20910 wxPyEndAllowThreads(__tstate);
20911 if (PyErr_Occurred()) SWIG_fail;
20912 }
20913 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20914 return resultobj;
20915 fail:
20916 return NULL;
20917 }
20918
20919
20920 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20921 PyObject *resultobj = 0;
20922 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20923 int result;
20924 void *argp1 = 0 ;
20925 int res1 = 0 ;
20926 PyObject *swig_obj[1] ;
20927
20928 if (!args) SWIG_fail;
20929 swig_obj[0] = args;
20930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20931 if (!SWIG_IsOK(res1)) {
20932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20933 }
20934 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20935 {
20936 PyThreadState* __tstate = wxPyBeginAllowThreads();
20937 result = (int)((wxMouseEvent const *)arg1)->GetX();
20938 wxPyEndAllowThreads(__tstate);
20939 if (PyErr_Occurred()) SWIG_fail;
20940 }
20941 resultobj = SWIG_From_int(static_cast< int >(result));
20942 return resultobj;
20943 fail:
20944 return NULL;
20945 }
20946
20947
20948 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20949 PyObject *resultobj = 0;
20950 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20951 int result;
20952 void *argp1 = 0 ;
20953 int res1 = 0 ;
20954 PyObject *swig_obj[1] ;
20955
20956 if (!args) SWIG_fail;
20957 swig_obj[0] = args;
20958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20959 if (!SWIG_IsOK(res1)) {
20960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20961 }
20962 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20963 {
20964 PyThreadState* __tstate = wxPyBeginAllowThreads();
20965 result = (int)((wxMouseEvent const *)arg1)->GetY();
20966 wxPyEndAllowThreads(__tstate);
20967 if (PyErr_Occurred()) SWIG_fail;
20968 }
20969 resultobj = SWIG_From_int(static_cast< int >(result));
20970 return resultobj;
20971 fail:
20972 return NULL;
20973 }
20974
20975
20976 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20977 PyObject *resultobj = 0;
20978 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20979 int result;
20980 void *argp1 = 0 ;
20981 int res1 = 0 ;
20982 PyObject *swig_obj[1] ;
20983
20984 if (!args) SWIG_fail;
20985 swig_obj[0] = args;
20986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20987 if (!SWIG_IsOK(res1)) {
20988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20989 }
20990 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20991 {
20992 PyThreadState* __tstate = wxPyBeginAllowThreads();
20993 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20994 wxPyEndAllowThreads(__tstate);
20995 if (PyErr_Occurred()) SWIG_fail;
20996 }
20997 resultobj = SWIG_From_int(static_cast< int >(result));
20998 return resultobj;
20999 fail:
21000 return NULL;
21001 }
21002
21003
21004 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21005 PyObject *resultobj = 0;
21006 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21007 int result;
21008 void *argp1 = 0 ;
21009 int res1 = 0 ;
21010 PyObject *swig_obj[1] ;
21011
21012 if (!args) SWIG_fail;
21013 swig_obj[0] = args;
21014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21015 if (!SWIG_IsOK(res1)) {
21016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21017 }
21018 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21019 {
21020 PyThreadState* __tstate = wxPyBeginAllowThreads();
21021 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21022 wxPyEndAllowThreads(__tstate);
21023 if (PyErr_Occurred()) SWIG_fail;
21024 }
21025 resultobj = SWIG_From_int(static_cast< int >(result));
21026 return resultobj;
21027 fail:
21028 return NULL;
21029 }
21030
21031
21032 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21033 PyObject *resultobj = 0;
21034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21035 int result;
21036 void *argp1 = 0 ;
21037 int res1 = 0 ;
21038 PyObject *swig_obj[1] ;
21039
21040 if (!args) SWIG_fail;
21041 swig_obj[0] = args;
21042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21043 if (!SWIG_IsOK(res1)) {
21044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21045 }
21046 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21047 {
21048 PyThreadState* __tstate = wxPyBeginAllowThreads();
21049 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21050 wxPyEndAllowThreads(__tstate);
21051 if (PyErr_Occurred()) SWIG_fail;
21052 }
21053 resultobj = SWIG_From_int(static_cast< int >(result));
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21061 PyObject *resultobj = 0;
21062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21063 bool result;
21064 void *argp1 = 0 ;
21065 int res1 = 0 ;
21066 PyObject *swig_obj[1] ;
21067
21068 if (!args) SWIG_fail;
21069 swig_obj[0] = args;
21070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21071 if (!SWIG_IsOK(res1)) {
21072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21073 }
21074 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21075 {
21076 PyThreadState* __tstate = wxPyBeginAllowThreads();
21077 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21078 wxPyEndAllowThreads(__tstate);
21079 if (PyErr_Occurred()) SWIG_fail;
21080 }
21081 {
21082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21083 }
21084 return resultobj;
21085 fail:
21086 return NULL;
21087 }
21088
21089
21090 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21091 PyObject *resultobj = 0;
21092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21093 int arg2 ;
21094 void *argp1 = 0 ;
21095 int res1 = 0 ;
21096 int val2 ;
21097 int ecode2 = 0 ;
21098 PyObject *swig_obj[2] ;
21099
21100 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21102 if (!SWIG_IsOK(res1)) {
21103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21104 }
21105 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21106 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21107 if (!SWIG_IsOK(ecode2)) {
21108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21109 }
21110 arg2 = static_cast< int >(val2);
21111 if (arg1) (arg1)->m_x = arg2;
21112
21113 resultobj = SWIG_Py_Void();
21114 return resultobj;
21115 fail:
21116 return NULL;
21117 }
21118
21119
21120 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21121 PyObject *resultobj = 0;
21122 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21123 int result;
21124 void *argp1 = 0 ;
21125 int res1 = 0 ;
21126 PyObject *swig_obj[1] ;
21127
21128 if (!args) SWIG_fail;
21129 swig_obj[0] = args;
21130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21131 if (!SWIG_IsOK(res1)) {
21132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21133 }
21134 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21135 result = (int) ((arg1)->m_x);
21136 resultobj = SWIG_From_int(static_cast< int >(result));
21137 return resultobj;
21138 fail:
21139 return NULL;
21140 }
21141
21142
21143 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21144 PyObject *resultobj = 0;
21145 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21146 int arg2 ;
21147 void *argp1 = 0 ;
21148 int res1 = 0 ;
21149 int val2 ;
21150 int ecode2 = 0 ;
21151 PyObject *swig_obj[2] ;
21152
21153 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21155 if (!SWIG_IsOK(res1)) {
21156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21157 }
21158 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21159 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21160 if (!SWIG_IsOK(ecode2)) {
21161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21162 }
21163 arg2 = static_cast< int >(val2);
21164 if (arg1) (arg1)->m_y = arg2;
21165
21166 resultobj = SWIG_Py_Void();
21167 return resultobj;
21168 fail:
21169 return NULL;
21170 }
21171
21172
21173 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21174 PyObject *resultobj = 0;
21175 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21176 int result;
21177 void *argp1 = 0 ;
21178 int res1 = 0 ;
21179 PyObject *swig_obj[1] ;
21180
21181 if (!args) SWIG_fail;
21182 swig_obj[0] = args;
21183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21184 if (!SWIG_IsOK(res1)) {
21185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21186 }
21187 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21188 result = (int) ((arg1)->m_y);
21189 resultobj = SWIG_From_int(static_cast< int >(result));
21190 return resultobj;
21191 fail:
21192 return NULL;
21193 }
21194
21195
21196 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21197 PyObject *resultobj = 0;
21198 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21199 bool arg2 ;
21200 void *argp1 = 0 ;
21201 int res1 = 0 ;
21202 bool val2 ;
21203 int ecode2 = 0 ;
21204 PyObject *swig_obj[2] ;
21205
21206 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21208 if (!SWIG_IsOK(res1)) {
21209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21210 }
21211 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21212 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21213 if (!SWIG_IsOK(ecode2)) {
21214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21215 }
21216 arg2 = static_cast< bool >(val2);
21217 if (arg1) (arg1)->m_leftDown = arg2;
21218
21219 resultobj = SWIG_Py_Void();
21220 return resultobj;
21221 fail:
21222 return NULL;
21223 }
21224
21225
21226 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21227 PyObject *resultobj = 0;
21228 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21229 bool result;
21230 void *argp1 = 0 ;
21231 int res1 = 0 ;
21232 PyObject *swig_obj[1] ;
21233
21234 if (!args) SWIG_fail;
21235 swig_obj[0] = args;
21236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21237 if (!SWIG_IsOK(res1)) {
21238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21239 }
21240 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21241 result = (bool) ((arg1)->m_leftDown);
21242 {
21243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21244 }
21245 return resultobj;
21246 fail:
21247 return NULL;
21248 }
21249
21250
21251 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21252 PyObject *resultobj = 0;
21253 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21254 bool arg2 ;
21255 void *argp1 = 0 ;
21256 int res1 = 0 ;
21257 bool val2 ;
21258 int ecode2 = 0 ;
21259 PyObject *swig_obj[2] ;
21260
21261 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21263 if (!SWIG_IsOK(res1)) {
21264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21265 }
21266 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21267 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21268 if (!SWIG_IsOK(ecode2)) {
21269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21270 }
21271 arg2 = static_cast< bool >(val2);
21272 if (arg1) (arg1)->m_middleDown = arg2;
21273
21274 resultobj = SWIG_Py_Void();
21275 return resultobj;
21276 fail:
21277 return NULL;
21278 }
21279
21280
21281 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21282 PyObject *resultobj = 0;
21283 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21284 bool result;
21285 void *argp1 = 0 ;
21286 int res1 = 0 ;
21287 PyObject *swig_obj[1] ;
21288
21289 if (!args) SWIG_fail;
21290 swig_obj[0] = args;
21291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21292 if (!SWIG_IsOK(res1)) {
21293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21294 }
21295 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21296 result = (bool) ((arg1)->m_middleDown);
21297 {
21298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21299 }
21300 return resultobj;
21301 fail:
21302 return NULL;
21303 }
21304
21305
21306 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21307 PyObject *resultobj = 0;
21308 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21309 bool arg2 ;
21310 void *argp1 = 0 ;
21311 int res1 = 0 ;
21312 bool val2 ;
21313 int ecode2 = 0 ;
21314 PyObject *swig_obj[2] ;
21315
21316 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21318 if (!SWIG_IsOK(res1)) {
21319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21320 }
21321 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21322 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21323 if (!SWIG_IsOK(ecode2)) {
21324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21325 }
21326 arg2 = static_cast< bool >(val2);
21327 if (arg1) (arg1)->m_rightDown = arg2;
21328
21329 resultobj = SWIG_Py_Void();
21330 return resultobj;
21331 fail:
21332 return NULL;
21333 }
21334
21335
21336 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21337 PyObject *resultobj = 0;
21338 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21339 bool result;
21340 void *argp1 = 0 ;
21341 int res1 = 0 ;
21342 PyObject *swig_obj[1] ;
21343
21344 if (!args) SWIG_fail;
21345 swig_obj[0] = args;
21346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21347 if (!SWIG_IsOK(res1)) {
21348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21349 }
21350 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21351 result = (bool) ((arg1)->m_rightDown);
21352 {
21353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21354 }
21355 return resultobj;
21356 fail:
21357 return NULL;
21358 }
21359
21360
21361 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21362 PyObject *resultobj = 0;
21363 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21364 bool arg2 ;
21365 void *argp1 = 0 ;
21366 int res1 = 0 ;
21367 bool val2 ;
21368 int ecode2 = 0 ;
21369 PyObject *swig_obj[2] ;
21370
21371 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21373 if (!SWIG_IsOK(res1)) {
21374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21375 }
21376 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21377 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21378 if (!SWIG_IsOK(ecode2)) {
21379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21380 }
21381 arg2 = static_cast< bool >(val2);
21382 if (arg1) (arg1)->m_controlDown = arg2;
21383
21384 resultobj = SWIG_Py_Void();
21385 return resultobj;
21386 fail:
21387 return NULL;
21388 }
21389
21390
21391 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21392 PyObject *resultobj = 0;
21393 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21394 bool result;
21395 void *argp1 = 0 ;
21396 int res1 = 0 ;
21397 PyObject *swig_obj[1] ;
21398
21399 if (!args) SWIG_fail;
21400 swig_obj[0] = args;
21401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21402 if (!SWIG_IsOK(res1)) {
21403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21404 }
21405 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21406 result = (bool) ((arg1)->m_controlDown);
21407 {
21408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21409 }
21410 return resultobj;
21411 fail:
21412 return NULL;
21413 }
21414
21415
21416 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21417 PyObject *resultobj = 0;
21418 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21419 bool arg2 ;
21420 void *argp1 = 0 ;
21421 int res1 = 0 ;
21422 bool val2 ;
21423 int ecode2 = 0 ;
21424 PyObject *swig_obj[2] ;
21425
21426 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21428 if (!SWIG_IsOK(res1)) {
21429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21430 }
21431 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21432 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21433 if (!SWIG_IsOK(ecode2)) {
21434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21435 }
21436 arg2 = static_cast< bool >(val2);
21437 if (arg1) (arg1)->m_shiftDown = arg2;
21438
21439 resultobj = SWIG_Py_Void();
21440 return resultobj;
21441 fail:
21442 return NULL;
21443 }
21444
21445
21446 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21447 PyObject *resultobj = 0;
21448 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21449 bool result;
21450 void *argp1 = 0 ;
21451 int res1 = 0 ;
21452 PyObject *swig_obj[1] ;
21453
21454 if (!args) SWIG_fail;
21455 swig_obj[0] = args;
21456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21457 if (!SWIG_IsOK(res1)) {
21458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21459 }
21460 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21461 result = (bool) ((arg1)->m_shiftDown);
21462 {
21463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21464 }
21465 return resultobj;
21466 fail:
21467 return NULL;
21468 }
21469
21470
21471 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21472 PyObject *resultobj = 0;
21473 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21474 bool arg2 ;
21475 void *argp1 = 0 ;
21476 int res1 = 0 ;
21477 bool val2 ;
21478 int ecode2 = 0 ;
21479 PyObject *swig_obj[2] ;
21480
21481 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21483 if (!SWIG_IsOK(res1)) {
21484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21485 }
21486 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21487 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21488 if (!SWIG_IsOK(ecode2)) {
21489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21490 }
21491 arg2 = static_cast< bool >(val2);
21492 if (arg1) (arg1)->m_altDown = arg2;
21493
21494 resultobj = SWIG_Py_Void();
21495 return resultobj;
21496 fail:
21497 return NULL;
21498 }
21499
21500
21501 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21502 PyObject *resultobj = 0;
21503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21504 bool result;
21505 void *argp1 = 0 ;
21506 int res1 = 0 ;
21507 PyObject *swig_obj[1] ;
21508
21509 if (!args) SWIG_fail;
21510 swig_obj[0] = args;
21511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21512 if (!SWIG_IsOK(res1)) {
21513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21514 }
21515 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21516 result = (bool) ((arg1)->m_altDown);
21517 {
21518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21519 }
21520 return resultobj;
21521 fail:
21522 return NULL;
21523 }
21524
21525
21526 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21527 PyObject *resultobj = 0;
21528 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21529 bool arg2 ;
21530 void *argp1 = 0 ;
21531 int res1 = 0 ;
21532 bool val2 ;
21533 int ecode2 = 0 ;
21534 PyObject *swig_obj[2] ;
21535
21536 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21538 if (!SWIG_IsOK(res1)) {
21539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21540 }
21541 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21542 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21543 if (!SWIG_IsOK(ecode2)) {
21544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21545 }
21546 arg2 = static_cast< bool >(val2);
21547 if (arg1) (arg1)->m_metaDown = arg2;
21548
21549 resultobj = SWIG_Py_Void();
21550 return resultobj;
21551 fail:
21552 return NULL;
21553 }
21554
21555
21556 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21557 PyObject *resultobj = 0;
21558 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21559 bool result;
21560 void *argp1 = 0 ;
21561 int res1 = 0 ;
21562 PyObject *swig_obj[1] ;
21563
21564 if (!args) SWIG_fail;
21565 swig_obj[0] = args;
21566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21567 if (!SWIG_IsOK(res1)) {
21568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21569 }
21570 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21571 result = (bool) ((arg1)->m_metaDown);
21572 {
21573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21574 }
21575 return resultobj;
21576 fail:
21577 return NULL;
21578 }
21579
21580
21581 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21582 PyObject *resultobj = 0;
21583 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21584 int arg2 ;
21585 void *argp1 = 0 ;
21586 int res1 = 0 ;
21587 int val2 ;
21588 int ecode2 = 0 ;
21589 PyObject *swig_obj[2] ;
21590
21591 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21593 if (!SWIG_IsOK(res1)) {
21594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21595 }
21596 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21597 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21598 if (!SWIG_IsOK(ecode2)) {
21599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21600 }
21601 arg2 = static_cast< int >(val2);
21602 if (arg1) (arg1)->m_wheelRotation = arg2;
21603
21604 resultobj = SWIG_Py_Void();
21605 return resultobj;
21606 fail:
21607 return NULL;
21608 }
21609
21610
21611 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21612 PyObject *resultobj = 0;
21613 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21614 int result;
21615 void *argp1 = 0 ;
21616 int res1 = 0 ;
21617 PyObject *swig_obj[1] ;
21618
21619 if (!args) SWIG_fail;
21620 swig_obj[0] = args;
21621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21622 if (!SWIG_IsOK(res1)) {
21623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21624 }
21625 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21626 result = (int) ((arg1)->m_wheelRotation);
21627 resultobj = SWIG_From_int(static_cast< int >(result));
21628 return resultobj;
21629 fail:
21630 return NULL;
21631 }
21632
21633
21634 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21635 PyObject *resultobj = 0;
21636 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21637 int arg2 ;
21638 void *argp1 = 0 ;
21639 int res1 = 0 ;
21640 int val2 ;
21641 int ecode2 = 0 ;
21642 PyObject *swig_obj[2] ;
21643
21644 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21646 if (!SWIG_IsOK(res1)) {
21647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21648 }
21649 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21650 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21651 if (!SWIG_IsOK(ecode2)) {
21652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21653 }
21654 arg2 = static_cast< int >(val2);
21655 if (arg1) (arg1)->m_wheelDelta = arg2;
21656
21657 resultobj = SWIG_Py_Void();
21658 return resultobj;
21659 fail:
21660 return NULL;
21661 }
21662
21663
21664 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21665 PyObject *resultobj = 0;
21666 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21667 int result;
21668 void *argp1 = 0 ;
21669 int res1 = 0 ;
21670 PyObject *swig_obj[1] ;
21671
21672 if (!args) SWIG_fail;
21673 swig_obj[0] = args;
21674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21675 if (!SWIG_IsOK(res1)) {
21676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21677 }
21678 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21679 result = (int) ((arg1)->m_wheelDelta);
21680 resultobj = SWIG_From_int(static_cast< int >(result));
21681 return resultobj;
21682 fail:
21683 return NULL;
21684 }
21685
21686
21687 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21688 PyObject *resultobj = 0;
21689 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21690 int arg2 ;
21691 void *argp1 = 0 ;
21692 int res1 = 0 ;
21693 int val2 ;
21694 int ecode2 = 0 ;
21695 PyObject *swig_obj[2] ;
21696
21697 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21699 if (!SWIG_IsOK(res1)) {
21700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21701 }
21702 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21703 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21704 if (!SWIG_IsOK(ecode2)) {
21705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21706 }
21707 arg2 = static_cast< int >(val2);
21708 if (arg1) (arg1)->m_linesPerAction = arg2;
21709
21710 resultobj = SWIG_Py_Void();
21711 return resultobj;
21712 fail:
21713 return NULL;
21714 }
21715
21716
21717 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21718 PyObject *resultobj = 0;
21719 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21720 int result;
21721 void *argp1 = 0 ;
21722 int res1 = 0 ;
21723 PyObject *swig_obj[1] ;
21724
21725 if (!args) SWIG_fail;
21726 swig_obj[0] = args;
21727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21728 if (!SWIG_IsOK(res1)) {
21729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21730 }
21731 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21732 result = (int) ((arg1)->m_linesPerAction);
21733 resultobj = SWIG_From_int(static_cast< int >(result));
21734 return resultobj;
21735 fail:
21736 return NULL;
21737 }
21738
21739
21740 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21741 PyObject *obj;
21742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21743 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21744 return SWIG_Py_Void();
21745 }
21746
21747 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21748 return SWIG_Python_InitShadowInstance(args);
21749 }
21750
21751 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21752 PyObject *resultobj = 0;
21753 int arg1 = (int) 0 ;
21754 int arg2 = (int) 0 ;
21755 wxSetCursorEvent *result = 0 ;
21756 int val1 ;
21757 int ecode1 = 0 ;
21758 int val2 ;
21759 int ecode2 = 0 ;
21760 PyObject * obj0 = 0 ;
21761 PyObject * obj1 = 0 ;
21762 char * kwnames[] = {
21763 (char *) "x",(char *) "y", NULL
21764 };
21765
21766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21767 if (obj0) {
21768 ecode1 = SWIG_AsVal_int(obj0, &val1);
21769 if (!SWIG_IsOK(ecode1)) {
21770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21771 }
21772 arg1 = static_cast< int >(val1);
21773 }
21774 if (obj1) {
21775 ecode2 = SWIG_AsVal_int(obj1, &val2);
21776 if (!SWIG_IsOK(ecode2)) {
21777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21778 }
21779 arg2 = static_cast< int >(val2);
21780 }
21781 {
21782 PyThreadState* __tstate = wxPyBeginAllowThreads();
21783 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21784 wxPyEndAllowThreads(__tstate);
21785 if (PyErr_Occurred()) SWIG_fail;
21786 }
21787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21788 return resultobj;
21789 fail:
21790 return NULL;
21791 }
21792
21793
21794 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21795 PyObject *resultobj = 0;
21796 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21797 int result;
21798 void *argp1 = 0 ;
21799 int res1 = 0 ;
21800 PyObject *swig_obj[1] ;
21801
21802 if (!args) SWIG_fail;
21803 swig_obj[0] = args;
21804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21805 if (!SWIG_IsOK(res1)) {
21806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21807 }
21808 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21809 {
21810 PyThreadState* __tstate = wxPyBeginAllowThreads();
21811 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21812 wxPyEndAllowThreads(__tstate);
21813 if (PyErr_Occurred()) SWIG_fail;
21814 }
21815 resultobj = SWIG_From_int(static_cast< int >(result));
21816 return resultobj;
21817 fail:
21818 return NULL;
21819 }
21820
21821
21822 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21823 PyObject *resultobj = 0;
21824 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21825 int result;
21826 void *argp1 = 0 ;
21827 int res1 = 0 ;
21828 PyObject *swig_obj[1] ;
21829
21830 if (!args) SWIG_fail;
21831 swig_obj[0] = args;
21832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21833 if (!SWIG_IsOK(res1)) {
21834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21835 }
21836 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21837 {
21838 PyThreadState* __tstate = wxPyBeginAllowThreads();
21839 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21840 wxPyEndAllowThreads(__tstate);
21841 if (PyErr_Occurred()) SWIG_fail;
21842 }
21843 resultobj = SWIG_From_int(static_cast< int >(result));
21844 return resultobj;
21845 fail:
21846 return NULL;
21847 }
21848
21849
21850 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21851 PyObject *resultobj = 0;
21852 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21853 wxCursor *arg2 = 0 ;
21854 void *argp1 = 0 ;
21855 int res1 = 0 ;
21856 void *argp2 = 0 ;
21857 int res2 = 0 ;
21858 PyObject * obj0 = 0 ;
21859 PyObject * obj1 = 0 ;
21860 char * kwnames[] = {
21861 (char *) "self",(char *) "cursor", NULL
21862 };
21863
21864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21866 if (!SWIG_IsOK(res1)) {
21867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21868 }
21869 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21870 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21871 if (!SWIG_IsOK(res2)) {
21872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21873 }
21874 if (!argp2) {
21875 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21876 }
21877 arg2 = reinterpret_cast< wxCursor * >(argp2);
21878 {
21879 PyThreadState* __tstate = wxPyBeginAllowThreads();
21880 (arg1)->SetCursor((wxCursor const &)*arg2);
21881 wxPyEndAllowThreads(__tstate);
21882 if (PyErr_Occurred()) SWIG_fail;
21883 }
21884 resultobj = SWIG_Py_Void();
21885 return resultobj;
21886 fail:
21887 return NULL;
21888 }
21889
21890
21891 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21892 PyObject *resultobj = 0;
21893 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21894 wxCursor *result = 0 ;
21895 void *argp1 = 0 ;
21896 int res1 = 0 ;
21897 PyObject *swig_obj[1] ;
21898
21899 if (!args) SWIG_fail;
21900 swig_obj[0] = args;
21901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21902 if (!SWIG_IsOK(res1)) {
21903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21904 }
21905 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21906 {
21907 PyThreadState* __tstate = wxPyBeginAllowThreads();
21908 {
21909 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21910 result = (wxCursor *) &_result_ref;
21911 }
21912 wxPyEndAllowThreads(__tstate);
21913 if (PyErr_Occurred()) SWIG_fail;
21914 }
21915 {
21916 wxCursor* resultptr = new wxCursor(*result);
21917 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21918 }
21919 return resultobj;
21920 fail:
21921 return NULL;
21922 }
21923
21924
21925 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21926 PyObject *resultobj = 0;
21927 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21928 bool result;
21929 void *argp1 = 0 ;
21930 int res1 = 0 ;
21931 PyObject *swig_obj[1] ;
21932
21933 if (!args) SWIG_fail;
21934 swig_obj[0] = args;
21935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21936 if (!SWIG_IsOK(res1)) {
21937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21938 }
21939 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21940 {
21941 PyThreadState* __tstate = wxPyBeginAllowThreads();
21942 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21943 wxPyEndAllowThreads(__tstate);
21944 if (PyErr_Occurred()) SWIG_fail;
21945 }
21946 {
21947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21948 }
21949 return resultobj;
21950 fail:
21951 return NULL;
21952 }
21953
21954
21955 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21956 PyObject *obj;
21957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21958 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21959 return SWIG_Py_Void();
21960 }
21961
21962 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21963 return SWIG_Python_InitShadowInstance(args);
21964 }
21965
21966 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21967 PyObject *resultobj = 0;
21968 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21969 wxKeyEvent *result = 0 ;
21970 int val1 ;
21971 int ecode1 = 0 ;
21972 PyObject * obj0 = 0 ;
21973 char * kwnames[] = {
21974 (char *) "eventType", NULL
21975 };
21976
21977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21978 if (obj0) {
21979 ecode1 = SWIG_AsVal_int(obj0, &val1);
21980 if (!SWIG_IsOK(ecode1)) {
21981 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21982 }
21983 arg1 = static_cast< wxEventType >(val1);
21984 }
21985 {
21986 PyThreadState* __tstate = wxPyBeginAllowThreads();
21987 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21988 wxPyEndAllowThreads(__tstate);
21989 if (PyErr_Occurred()) SWIG_fail;
21990 }
21991 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21992 return resultobj;
21993 fail:
21994 return NULL;
21995 }
21996
21997
21998 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21999 PyObject *resultobj = 0;
22000 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22001 int result;
22002 void *argp1 = 0 ;
22003 int res1 = 0 ;
22004 PyObject *swig_obj[1] ;
22005
22006 if (!args) SWIG_fail;
22007 swig_obj[0] = args;
22008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22009 if (!SWIG_IsOK(res1)) {
22010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22011 }
22012 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22013 {
22014 PyThreadState* __tstate = wxPyBeginAllowThreads();
22015 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22016 wxPyEndAllowThreads(__tstate);
22017 if (PyErr_Occurred()) SWIG_fail;
22018 }
22019 resultobj = SWIG_From_int(static_cast< int >(result));
22020 return resultobj;
22021 fail:
22022 return NULL;
22023 }
22024
22025
22026 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22027 PyObject *resultobj = 0;
22028 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22029 bool result;
22030 void *argp1 = 0 ;
22031 int res1 = 0 ;
22032 PyObject *swig_obj[1] ;
22033
22034 if (!args) SWIG_fail;
22035 swig_obj[0] = args;
22036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22037 if (!SWIG_IsOK(res1)) {
22038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22039 }
22040 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22041 {
22042 PyThreadState* __tstate = wxPyBeginAllowThreads();
22043 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22044 wxPyEndAllowThreads(__tstate);
22045 if (PyErr_Occurred()) SWIG_fail;
22046 }
22047 {
22048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22049 }
22050 return resultobj;
22051 fail:
22052 return NULL;
22053 }
22054
22055
22056 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22057 PyObject *resultobj = 0;
22058 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22059 bool result;
22060 void *argp1 = 0 ;
22061 int res1 = 0 ;
22062 PyObject *swig_obj[1] ;
22063
22064 if (!args) SWIG_fail;
22065 swig_obj[0] = args;
22066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22067 if (!SWIG_IsOK(res1)) {
22068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22069 }
22070 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22071 {
22072 PyThreadState* __tstate = wxPyBeginAllowThreads();
22073 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22074 wxPyEndAllowThreads(__tstate);
22075 if (PyErr_Occurred()) SWIG_fail;
22076 }
22077 {
22078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22079 }
22080 return resultobj;
22081 fail:
22082 return NULL;
22083 }
22084
22085
22086 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22087 PyObject *resultobj = 0;
22088 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22089 bool result;
22090 void *argp1 = 0 ;
22091 int res1 = 0 ;
22092 PyObject *swig_obj[1] ;
22093
22094 if (!args) SWIG_fail;
22095 swig_obj[0] = args;
22096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22097 if (!SWIG_IsOK(res1)) {
22098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22099 }
22100 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22101 {
22102 PyThreadState* __tstate = wxPyBeginAllowThreads();
22103 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22104 wxPyEndAllowThreads(__tstate);
22105 if (PyErr_Occurred()) SWIG_fail;
22106 }
22107 {
22108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22109 }
22110 return resultobj;
22111 fail:
22112 return NULL;
22113 }
22114
22115
22116 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22117 PyObject *resultobj = 0;
22118 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22119 bool result;
22120 void *argp1 = 0 ;
22121 int res1 = 0 ;
22122 PyObject *swig_obj[1] ;
22123
22124 if (!args) SWIG_fail;
22125 swig_obj[0] = args;
22126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22127 if (!SWIG_IsOK(res1)) {
22128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22129 }
22130 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22131 {
22132 PyThreadState* __tstate = wxPyBeginAllowThreads();
22133 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22134 wxPyEndAllowThreads(__tstate);
22135 if (PyErr_Occurred()) SWIG_fail;
22136 }
22137 {
22138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22139 }
22140 return resultobj;
22141 fail:
22142 return NULL;
22143 }
22144
22145
22146 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22147 PyObject *resultobj = 0;
22148 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22149 bool result;
22150 void *argp1 = 0 ;
22151 int res1 = 0 ;
22152 PyObject *swig_obj[1] ;
22153
22154 if (!args) SWIG_fail;
22155 swig_obj[0] = args;
22156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22157 if (!SWIG_IsOK(res1)) {
22158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22159 }
22160 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22161 {
22162 PyThreadState* __tstate = wxPyBeginAllowThreads();
22163 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22164 wxPyEndAllowThreads(__tstate);
22165 if (PyErr_Occurred()) SWIG_fail;
22166 }
22167 {
22168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22169 }
22170 return resultobj;
22171 fail:
22172 return NULL;
22173 }
22174
22175
22176 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22177 PyObject *resultobj = 0;
22178 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22179 bool result;
22180 void *argp1 = 0 ;
22181 int res1 = 0 ;
22182 PyObject *swig_obj[1] ;
22183
22184 if (!args) SWIG_fail;
22185 swig_obj[0] = args;
22186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22187 if (!SWIG_IsOK(res1)) {
22188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22189 }
22190 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22191 {
22192 PyThreadState* __tstate = wxPyBeginAllowThreads();
22193 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22194 wxPyEndAllowThreads(__tstate);
22195 if (PyErr_Occurred()) SWIG_fail;
22196 }
22197 {
22198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22199 }
22200 return resultobj;
22201 fail:
22202 return NULL;
22203 }
22204
22205
22206 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22207 PyObject *resultobj = 0;
22208 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22209 int result;
22210 void *argp1 = 0 ;
22211 int res1 = 0 ;
22212 PyObject *swig_obj[1] ;
22213
22214 if (!args) SWIG_fail;
22215 swig_obj[0] = args;
22216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22217 if (!SWIG_IsOK(res1)) {
22218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22219 }
22220 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22221 {
22222 PyThreadState* __tstate = wxPyBeginAllowThreads();
22223 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22224 wxPyEndAllowThreads(__tstate);
22225 if (PyErr_Occurred()) SWIG_fail;
22226 }
22227 resultobj = SWIG_From_int(static_cast< int >(result));
22228 return resultobj;
22229 fail:
22230 return NULL;
22231 }
22232
22233
22234 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22235 PyObject *resultobj = 0;
22236 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22237 int result;
22238 void *argp1 = 0 ;
22239 int res1 = 0 ;
22240 PyObject *swig_obj[1] ;
22241
22242 if (!args) SWIG_fail;
22243 swig_obj[0] = args;
22244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22245 if (!SWIG_IsOK(res1)) {
22246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22247 }
22248 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22249 {
22250 PyThreadState* __tstate = wxPyBeginAllowThreads();
22251 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22252 wxPyEndAllowThreads(__tstate);
22253 if (PyErr_Occurred()) SWIG_fail;
22254 }
22255 resultobj = SWIG_From_int(static_cast< int >(result));
22256 return resultobj;
22257 fail:
22258 return NULL;
22259 }
22260
22261
22262 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22263 PyObject *resultobj = 0;
22264 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22265 int arg2 ;
22266 void *argp1 = 0 ;
22267 int res1 = 0 ;
22268 int val2 ;
22269 int ecode2 = 0 ;
22270 PyObject * obj0 = 0 ;
22271 PyObject * obj1 = 0 ;
22272 char * kwnames[] = {
22273 (char *) "self",(char *) "uniChar", NULL
22274 };
22275
22276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22278 if (!SWIG_IsOK(res1)) {
22279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22280 }
22281 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22282 ecode2 = SWIG_AsVal_int(obj1, &val2);
22283 if (!SWIG_IsOK(ecode2)) {
22284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22285 }
22286 arg2 = static_cast< int >(val2);
22287 {
22288 PyThreadState* __tstate = wxPyBeginAllowThreads();
22289 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22290 wxPyEndAllowThreads(__tstate);
22291 if (PyErr_Occurred()) SWIG_fail;
22292 }
22293 resultobj = SWIG_Py_Void();
22294 return resultobj;
22295 fail:
22296 return NULL;
22297 }
22298
22299
22300 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22301 PyObject *resultobj = 0;
22302 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22303 unsigned int result;
22304 void *argp1 = 0 ;
22305 int res1 = 0 ;
22306 PyObject *swig_obj[1] ;
22307
22308 if (!args) SWIG_fail;
22309 swig_obj[0] = args;
22310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22311 if (!SWIG_IsOK(res1)) {
22312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22313 }
22314 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22315 {
22316 PyThreadState* __tstate = wxPyBeginAllowThreads();
22317 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22318 wxPyEndAllowThreads(__tstate);
22319 if (PyErr_Occurred()) SWIG_fail;
22320 }
22321 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22322 return resultobj;
22323 fail:
22324 return NULL;
22325 }
22326
22327
22328 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22329 PyObject *resultobj = 0;
22330 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22331 unsigned int result;
22332 void *argp1 = 0 ;
22333 int res1 = 0 ;
22334 PyObject *swig_obj[1] ;
22335
22336 if (!args) SWIG_fail;
22337 swig_obj[0] = args;
22338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22339 if (!SWIG_IsOK(res1)) {
22340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22341 }
22342 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22343 {
22344 PyThreadState* __tstate = wxPyBeginAllowThreads();
22345 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22346 wxPyEndAllowThreads(__tstate);
22347 if (PyErr_Occurred()) SWIG_fail;
22348 }
22349 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22350 return resultobj;
22351 fail:
22352 return NULL;
22353 }
22354
22355
22356 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22357 PyObject *resultobj = 0;
22358 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22359 wxPoint 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_wxKeyEvent, 0 | 0 );
22367 if (!SWIG_IsOK(res1)) {
22368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22369 }
22370 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22371 {
22372 PyThreadState* __tstate = wxPyBeginAllowThreads();
22373 result = (arg1)->GetPosition();
22374 wxPyEndAllowThreads(__tstate);
22375 if (PyErr_Occurred()) SWIG_fail;
22376 }
22377 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22378 return resultobj;
22379 fail:
22380 return NULL;
22381 }
22382
22383
22384 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22385 PyObject *resultobj = 0;
22386 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22387 long *arg2 = (long *) 0 ;
22388 long *arg3 = (long *) 0 ;
22389 void *argp1 = 0 ;
22390 int res1 = 0 ;
22391 long temp2 ;
22392 int res2 = SWIG_TMPOBJ ;
22393 long temp3 ;
22394 int res3 = SWIG_TMPOBJ ;
22395 PyObject *swig_obj[1] ;
22396
22397 arg2 = &temp2;
22398 arg3 = &temp3;
22399 if (!args) SWIG_fail;
22400 swig_obj[0] = args;
22401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22402 if (!SWIG_IsOK(res1)) {
22403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22404 }
22405 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22406 {
22407 PyThreadState* __tstate = wxPyBeginAllowThreads();
22408 (arg1)->GetPosition(arg2,arg3);
22409 wxPyEndAllowThreads(__tstate);
22410 if (PyErr_Occurred()) SWIG_fail;
22411 }
22412 resultobj = SWIG_Py_Void();
22413 if (SWIG_IsTmpObj(res2)) {
22414 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22415 } else {
22416 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22417 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22418 }
22419 if (SWIG_IsTmpObj(res3)) {
22420 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22421 } else {
22422 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22424 }
22425 return resultobj;
22426 fail:
22427 return NULL;
22428 }
22429
22430
22431 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22432 PyObject *resultobj = 0;
22433 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22434 int result;
22435 void *argp1 = 0 ;
22436 int res1 = 0 ;
22437 PyObject *swig_obj[1] ;
22438
22439 if (!args) SWIG_fail;
22440 swig_obj[0] = args;
22441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22442 if (!SWIG_IsOK(res1)) {
22443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22444 }
22445 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22446 {
22447 PyThreadState* __tstate = wxPyBeginAllowThreads();
22448 result = (int)((wxKeyEvent const *)arg1)->GetX();
22449 wxPyEndAllowThreads(__tstate);
22450 if (PyErr_Occurred()) SWIG_fail;
22451 }
22452 resultobj = SWIG_From_int(static_cast< int >(result));
22453 return resultobj;
22454 fail:
22455 return NULL;
22456 }
22457
22458
22459 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22460 PyObject *resultobj = 0;
22461 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22462 int result;
22463 void *argp1 = 0 ;
22464 int res1 = 0 ;
22465 PyObject *swig_obj[1] ;
22466
22467 if (!args) SWIG_fail;
22468 swig_obj[0] = args;
22469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22470 if (!SWIG_IsOK(res1)) {
22471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22472 }
22473 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22474 {
22475 PyThreadState* __tstate = wxPyBeginAllowThreads();
22476 result = (int)((wxKeyEvent const *)arg1)->GetY();
22477 wxPyEndAllowThreads(__tstate);
22478 if (PyErr_Occurred()) SWIG_fail;
22479 }
22480 resultobj = SWIG_From_int(static_cast< int >(result));
22481 return resultobj;
22482 fail:
22483 return NULL;
22484 }
22485
22486
22487 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22488 PyObject *resultobj = 0;
22489 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22490 int arg2 ;
22491 void *argp1 = 0 ;
22492 int res1 = 0 ;
22493 int val2 ;
22494 int ecode2 = 0 ;
22495 PyObject *swig_obj[2] ;
22496
22497 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22499 if (!SWIG_IsOK(res1)) {
22500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22501 }
22502 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22503 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22504 if (!SWIG_IsOK(ecode2)) {
22505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22506 }
22507 arg2 = static_cast< int >(val2);
22508 if (arg1) (arg1)->m_x = arg2;
22509
22510 resultobj = SWIG_Py_Void();
22511 return resultobj;
22512 fail:
22513 return NULL;
22514 }
22515
22516
22517 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22518 PyObject *resultobj = 0;
22519 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22520 int result;
22521 void *argp1 = 0 ;
22522 int res1 = 0 ;
22523 PyObject *swig_obj[1] ;
22524
22525 if (!args) SWIG_fail;
22526 swig_obj[0] = args;
22527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22528 if (!SWIG_IsOK(res1)) {
22529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22530 }
22531 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22532 result = (int) ((arg1)->m_x);
22533 resultobj = SWIG_From_int(static_cast< int >(result));
22534 return resultobj;
22535 fail:
22536 return NULL;
22537 }
22538
22539
22540 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22541 PyObject *resultobj = 0;
22542 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22543 int arg2 ;
22544 void *argp1 = 0 ;
22545 int res1 = 0 ;
22546 int val2 ;
22547 int ecode2 = 0 ;
22548 PyObject *swig_obj[2] ;
22549
22550 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22552 if (!SWIG_IsOK(res1)) {
22553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22554 }
22555 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22556 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22557 if (!SWIG_IsOK(ecode2)) {
22558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22559 }
22560 arg2 = static_cast< int >(val2);
22561 if (arg1) (arg1)->m_y = arg2;
22562
22563 resultobj = SWIG_Py_Void();
22564 return resultobj;
22565 fail:
22566 return NULL;
22567 }
22568
22569
22570 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22571 PyObject *resultobj = 0;
22572 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22573 int result;
22574 void *argp1 = 0 ;
22575 int res1 = 0 ;
22576 PyObject *swig_obj[1] ;
22577
22578 if (!args) SWIG_fail;
22579 swig_obj[0] = args;
22580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22581 if (!SWIG_IsOK(res1)) {
22582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22583 }
22584 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22585 result = (int) ((arg1)->m_y);
22586 resultobj = SWIG_From_int(static_cast< int >(result));
22587 return resultobj;
22588 fail:
22589 return NULL;
22590 }
22591
22592
22593 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22594 PyObject *resultobj = 0;
22595 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22596 long arg2 ;
22597 void *argp1 = 0 ;
22598 int res1 = 0 ;
22599 long val2 ;
22600 int ecode2 = 0 ;
22601 PyObject *swig_obj[2] ;
22602
22603 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22605 if (!SWIG_IsOK(res1)) {
22606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22607 }
22608 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22609 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22610 if (!SWIG_IsOK(ecode2)) {
22611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22612 }
22613 arg2 = static_cast< long >(val2);
22614 if (arg1) (arg1)->m_keyCode = arg2;
22615
22616 resultobj = SWIG_Py_Void();
22617 return resultobj;
22618 fail:
22619 return NULL;
22620 }
22621
22622
22623 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22624 PyObject *resultobj = 0;
22625 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22626 long result;
22627 void *argp1 = 0 ;
22628 int res1 = 0 ;
22629 PyObject *swig_obj[1] ;
22630
22631 if (!args) SWIG_fail;
22632 swig_obj[0] = args;
22633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22634 if (!SWIG_IsOK(res1)) {
22635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22636 }
22637 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22638 result = (long) ((arg1)->m_keyCode);
22639 resultobj = SWIG_From_long(static_cast< long >(result));
22640 return resultobj;
22641 fail:
22642 return NULL;
22643 }
22644
22645
22646 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22647 PyObject *resultobj = 0;
22648 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22649 bool arg2 ;
22650 void *argp1 = 0 ;
22651 int res1 = 0 ;
22652 bool val2 ;
22653 int ecode2 = 0 ;
22654 PyObject *swig_obj[2] ;
22655
22656 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22658 if (!SWIG_IsOK(res1)) {
22659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22660 }
22661 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22662 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22663 if (!SWIG_IsOK(ecode2)) {
22664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22665 }
22666 arg2 = static_cast< bool >(val2);
22667 if (arg1) (arg1)->m_controlDown = arg2;
22668
22669 resultobj = SWIG_Py_Void();
22670 return resultobj;
22671 fail:
22672 return NULL;
22673 }
22674
22675
22676 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22677 PyObject *resultobj = 0;
22678 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22679 bool result;
22680 void *argp1 = 0 ;
22681 int res1 = 0 ;
22682 PyObject *swig_obj[1] ;
22683
22684 if (!args) SWIG_fail;
22685 swig_obj[0] = args;
22686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22687 if (!SWIG_IsOK(res1)) {
22688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22689 }
22690 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22691 result = (bool) ((arg1)->m_controlDown);
22692 {
22693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22694 }
22695 return resultobj;
22696 fail:
22697 return NULL;
22698 }
22699
22700
22701 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22702 PyObject *resultobj = 0;
22703 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22704 bool arg2 ;
22705 void *argp1 = 0 ;
22706 int res1 = 0 ;
22707 bool val2 ;
22708 int ecode2 = 0 ;
22709 PyObject *swig_obj[2] ;
22710
22711 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22713 if (!SWIG_IsOK(res1)) {
22714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22715 }
22716 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22717 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22718 if (!SWIG_IsOK(ecode2)) {
22719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22720 }
22721 arg2 = static_cast< bool >(val2);
22722 if (arg1) (arg1)->m_shiftDown = arg2;
22723
22724 resultobj = SWIG_Py_Void();
22725 return resultobj;
22726 fail:
22727 return NULL;
22728 }
22729
22730
22731 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22732 PyObject *resultobj = 0;
22733 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22734 bool result;
22735 void *argp1 = 0 ;
22736 int res1 = 0 ;
22737 PyObject *swig_obj[1] ;
22738
22739 if (!args) SWIG_fail;
22740 swig_obj[0] = args;
22741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22742 if (!SWIG_IsOK(res1)) {
22743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22744 }
22745 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22746 result = (bool) ((arg1)->m_shiftDown);
22747 {
22748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22749 }
22750 return resultobj;
22751 fail:
22752 return NULL;
22753 }
22754
22755
22756 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22757 PyObject *resultobj = 0;
22758 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22759 bool arg2 ;
22760 void *argp1 = 0 ;
22761 int res1 = 0 ;
22762 bool val2 ;
22763 int ecode2 = 0 ;
22764 PyObject *swig_obj[2] ;
22765
22766 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22768 if (!SWIG_IsOK(res1)) {
22769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22770 }
22771 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22772 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22773 if (!SWIG_IsOK(ecode2)) {
22774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22775 }
22776 arg2 = static_cast< bool >(val2);
22777 if (arg1) (arg1)->m_altDown = arg2;
22778
22779 resultobj = SWIG_Py_Void();
22780 return resultobj;
22781 fail:
22782 return NULL;
22783 }
22784
22785
22786 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22787 PyObject *resultobj = 0;
22788 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22789 bool result;
22790 void *argp1 = 0 ;
22791 int res1 = 0 ;
22792 PyObject *swig_obj[1] ;
22793
22794 if (!args) SWIG_fail;
22795 swig_obj[0] = args;
22796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22797 if (!SWIG_IsOK(res1)) {
22798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22799 }
22800 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22801 result = (bool) ((arg1)->m_altDown);
22802 {
22803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22804 }
22805 return resultobj;
22806 fail:
22807 return NULL;
22808 }
22809
22810
22811 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22812 PyObject *resultobj = 0;
22813 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22814 bool arg2 ;
22815 void *argp1 = 0 ;
22816 int res1 = 0 ;
22817 bool val2 ;
22818 int ecode2 = 0 ;
22819 PyObject *swig_obj[2] ;
22820
22821 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22823 if (!SWIG_IsOK(res1)) {
22824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22825 }
22826 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22827 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22828 if (!SWIG_IsOK(ecode2)) {
22829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22830 }
22831 arg2 = static_cast< bool >(val2);
22832 if (arg1) (arg1)->m_metaDown = arg2;
22833
22834 resultobj = SWIG_Py_Void();
22835 return resultobj;
22836 fail:
22837 return NULL;
22838 }
22839
22840
22841 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22842 PyObject *resultobj = 0;
22843 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22844 bool result;
22845 void *argp1 = 0 ;
22846 int res1 = 0 ;
22847 PyObject *swig_obj[1] ;
22848
22849 if (!args) SWIG_fail;
22850 swig_obj[0] = args;
22851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22852 if (!SWIG_IsOK(res1)) {
22853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22854 }
22855 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22856 result = (bool) ((arg1)->m_metaDown);
22857 {
22858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22859 }
22860 return resultobj;
22861 fail:
22862 return NULL;
22863 }
22864
22865
22866 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22867 PyObject *resultobj = 0;
22868 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22869 bool arg2 ;
22870 void *argp1 = 0 ;
22871 int res1 = 0 ;
22872 bool val2 ;
22873 int ecode2 = 0 ;
22874 PyObject *swig_obj[2] ;
22875
22876 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22878 if (!SWIG_IsOK(res1)) {
22879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22880 }
22881 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22882 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22883 if (!SWIG_IsOK(ecode2)) {
22884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22885 }
22886 arg2 = static_cast< bool >(val2);
22887 if (arg1) (arg1)->m_scanCode = arg2;
22888
22889 resultobj = SWIG_Py_Void();
22890 return resultobj;
22891 fail:
22892 return NULL;
22893 }
22894
22895
22896 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22897 PyObject *resultobj = 0;
22898 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22899 bool result;
22900 void *argp1 = 0 ;
22901 int res1 = 0 ;
22902 PyObject *swig_obj[1] ;
22903
22904 if (!args) SWIG_fail;
22905 swig_obj[0] = args;
22906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22907 if (!SWIG_IsOK(res1)) {
22908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22909 }
22910 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22911 result = (bool) ((arg1)->m_scanCode);
22912 {
22913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22914 }
22915 return resultobj;
22916 fail:
22917 return NULL;
22918 }
22919
22920
22921 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22922 PyObject *resultobj = 0;
22923 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22924 unsigned int arg2 ;
22925 void *argp1 = 0 ;
22926 int res1 = 0 ;
22927 unsigned int val2 ;
22928 int ecode2 = 0 ;
22929 PyObject *swig_obj[2] ;
22930
22931 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22933 if (!SWIG_IsOK(res1)) {
22934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22935 }
22936 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22937 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22938 if (!SWIG_IsOK(ecode2)) {
22939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22940 }
22941 arg2 = static_cast< unsigned int >(val2);
22942 if (arg1) (arg1)->m_rawCode = arg2;
22943
22944 resultobj = SWIG_Py_Void();
22945 return resultobj;
22946 fail:
22947 return NULL;
22948 }
22949
22950
22951 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22952 PyObject *resultobj = 0;
22953 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22954 unsigned int result;
22955 void *argp1 = 0 ;
22956 int res1 = 0 ;
22957 PyObject *swig_obj[1] ;
22958
22959 if (!args) SWIG_fail;
22960 swig_obj[0] = args;
22961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22962 if (!SWIG_IsOK(res1)) {
22963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22964 }
22965 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22966 result = (unsigned int) ((arg1)->m_rawCode);
22967 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22968 return resultobj;
22969 fail:
22970 return NULL;
22971 }
22972
22973
22974 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22975 PyObject *resultobj = 0;
22976 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22977 unsigned int arg2 ;
22978 void *argp1 = 0 ;
22979 int res1 = 0 ;
22980 unsigned int val2 ;
22981 int ecode2 = 0 ;
22982 PyObject *swig_obj[2] ;
22983
22984 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22986 if (!SWIG_IsOK(res1)) {
22987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22988 }
22989 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22990 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22991 if (!SWIG_IsOK(ecode2)) {
22992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22993 }
22994 arg2 = static_cast< unsigned int >(val2);
22995 if (arg1) (arg1)->m_rawFlags = arg2;
22996
22997 resultobj = SWIG_Py_Void();
22998 return resultobj;
22999 fail:
23000 return NULL;
23001 }
23002
23003
23004 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23005 PyObject *resultobj = 0;
23006 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23007 unsigned int result;
23008 void *argp1 = 0 ;
23009 int res1 = 0 ;
23010 PyObject *swig_obj[1] ;
23011
23012 if (!args) SWIG_fail;
23013 swig_obj[0] = args;
23014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23015 if (!SWIG_IsOK(res1)) {
23016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23017 }
23018 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23019 result = (unsigned int) ((arg1)->m_rawFlags);
23020 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23021 return resultobj;
23022 fail:
23023 return NULL;
23024 }
23025
23026
23027 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23028 PyObject *obj;
23029 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23030 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23031 return SWIG_Py_Void();
23032 }
23033
23034 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23035 return SWIG_Python_InitShadowInstance(args);
23036 }
23037
23038 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23039 PyObject *resultobj = 0;
23040 wxSize const &arg1_defvalue = wxDefaultSize ;
23041 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23042 int arg2 = (int) 0 ;
23043 wxSizeEvent *result = 0 ;
23044 wxSize temp1 ;
23045 int val2 ;
23046 int ecode2 = 0 ;
23047 PyObject * obj0 = 0 ;
23048 PyObject * obj1 = 0 ;
23049 char * kwnames[] = {
23050 (char *) "sz",(char *) "winid", NULL
23051 };
23052
23053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23054 if (obj0) {
23055 {
23056 arg1 = &temp1;
23057 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23058 }
23059 }
23060 if (obj1) {
23061 ecode2 = SWIG_AsVal_int(obj1, &val2);
23062 if (!SWIG_IsOK(ecode2)) {
23063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23064 }
23065 arg2 = static_cast< int >(val2);
23066 }
23067 {
23068 PyThreadState* __tstate = wxPyBeginAllowThreads();
23069 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23070 wxPyEndAllowThreads(__tstate);
23071 if (PyErr_Occurred()) SWIG_fail;
23072 }
23073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23074 return resultobj;
23075 fail:
23076 return NULL;
23077 }
23078
23079
23080 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23081 PyObject *resultobj = 0;
23082 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23083 wxSize result;
23084 void *argp1 = 0 ;
23085 int res1 = 0 ;
23086 PyObject *swig_obj[1] ;
23087
23088 if (!args) SWIG_fail;
23089 swig_obj[0] = args;
23090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23091 if (!SWIG_IsOK(res1)) {
23092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23093 }
23094 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23095 {
23096 PyThreadState* __tstate = wxPyBeginAllowThreads();
23097 result = ((wxSizeEvent const *)arg1)->GetSize();
23098 wxPyEndAllowThreads(__tstate);
23099 if (PyErr_Occurred()) SWIG_fail;
23100 }
23101 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23102 return resultobj;
23103 fail:
23104 return NULL;
23105 }
23106
23107
23108 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23109 PyObject *resultobj = 0;
23110 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23111 wxRect result;
23112 void *argp1 = 0 ;
23113 int res1 = 0 ;
23114 PyObject *swig_obj[1] ;
23115
23116 if (!args) SWIG_fail;
23117 swig_obj[0] = args;
23118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23119 if (!SWIG_IsOK(res1)) {
23120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23121 }
23122 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23123 {
23124 PyThreadState* __tstate = wxPyBeginAllowThreads();
23125 result = ((wxSizeEvent const *)arg1)->GetRect();
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23130 return resultobj;
23131 fail:
23132 return NULL;
23133 }
23134
23135
23136 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23137 PyObject *resultobj = 0;
23138 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23139 wxRect arg2 ;
23140 void *argp1 = 0 ;
23141 int res1 = 0 ;
23142 void *argp2 ;
23143 int res2 = 0 ;
23144 PyObject * obj0 = 0 ;
23145 PyObject * obj1 = 0 ;
23146 char * kwnames[] = {
23147 (char *) "self",(char *) "rect", NULL
23148 };
23149
23150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23152 if (!SWIG_IsOK(res1)) {
23153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23154 }
23155 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23156 {
23157 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23158 if (!SWIG_IsOK(res2)) {
23159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23160 }
23161 if (!argp2) {
23162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23163 } else {
23164 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23165 arg2 = *temp;
23166 if (SWIG_IsNewObj(res2)) delete temp;
23167 }
23168 }
23169 {
23170 PyThreadState* __tstate = wxPyBeginAllowThreads();
23171 (arg1)->SetRect(arg2);
23172 wxPyEndAllowThreads(__tstate);
23173 if (PyErr_Occurred()) SWIG_fail;
23174 }
23175 resultobj = SWIG_Py_Void();
23176 return resultobj;
23177 fail:
23178 return NULL;
23179 }
23180
23181
23182 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23183 PyObject *resultobj = 0;
23184 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23185 wxSize arg2 ;
23186 void *argp1 = 0 ;
23187 int res1 = 0 ;
23188 void *argp2 ;
23189 int res2 = 0 ;
23190 PyObject * obj0 = 0 ;
23191 PyObject * obj1 = 0 ;
23192 char * kwnames[] = {
23193 (char *) "self",(char *) "size", NULL
23194 };
23195
23196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23198 if (!SWIG_IsOK(res1)) {
23199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23200 }
23201 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23202 {
23203 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23204 if (!SWIG_IsOK(res2)) {
23205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23206 }
23207 if (!argp2) {
23208 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23209 } else {
23210 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23211 arg2 = *temp;
23212 if (SWIG_IsNewObj(res2)) delete temp;
23213 }
23214 }
23215 {
23216 PyThreadState* __tstate = wxPyBeginAllowThreads();
23217 wxSizeEvent_SetSize(arg1,arg2);
23218 wxPyEndAllowThreads(__tstate);
23219 if (PyErr_Occurred()) SWIG_fail;
23220 }
23221 resultobj = SWIG_Py_Void();
23222 return resultobj;
23223 fail:
23224 return NULL;
23225 }
23226
23227
23228 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23229 PyObject *resultobj = 0;
23230 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23231 wxSize *arg2 = (wxSize *) 0 ;
23232 void *argp1 = 0 ;
23233 int res1 = 0 ;
23234 void *argp2 = 0 ;
23235 int res2 = 0 ;
23236 PyObject *swig_obj[2] ;
23237
23238 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23240 if (!SWIG_IsOK(res1)) {
23241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23242 }
23243 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23244 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23245 if (!SWIG_IsOK(res2)) {
23246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23247 }
23248 arg2 = reinterpret_cast< wxSize * >(argp2);
23249 if (arg1) (arg1)->m_size = *arg2;
23250
23251 resultobj = SWIG_Py_Void();
23252 return resultobj;
23253 fail:
23254 return NULL;
23255 }
23256
23257
23258 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23259 PyObject *resultobj = 0;
23260 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23261 wxSize *result = 0 ;
23262 void *argp1 = 0 ;
23263 int res1 = 0 ;
23264 PyObject *swig_obj[1] ;
23265
23266 if (!args) SWIG_fail;
23267 swig_obj[0] = args;
23268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23269 if (!SWIG_IsOK(res1)) {
23270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23271 }
23272 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23273 result = (wxSize *)& ((arg1)->m_size);
23274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23275 return resultobj;
23276 fail:
23277 return NULL;
23278 }
23279
23280
23281 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23282 PyObject *resultobj = 0;
23283 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23284 wxRect *arg2 = (wxRect *) 0 ;
23285 void *argp1 = 0 ;
23286 int res1 = 0 ;
23287 void *argp2 = 0 ;
23288 int res2 = 0 ;
23289 PyObject *swig_obj[2] ;
23290
23291 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23293 if (!SWIG_IsOK(res1)) {
23294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23295 }
23296 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23297 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23298 if (!SWIG_IsOK(res2)) {
23299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23300 }
23301 arg2 = reinterpret_cast< wxRect * >(argp2);
23302 if (arg1) (arg1)->m_rect = *arg2;
23303
23304 resultobj = SWIG_Py_Void();
23305 return resultobj;
23306 fail:
23307 return NULL;
23308 }
23309
23310
23311 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23312 PyObject *resultobj = 0;
23313 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23314 wxRect *result = 0 ;
23315 void *argp1 = 0 ;
23316 int res1 = 0 ;
23317 PyObject *swig_obj[1] ;
23318
23319 if (!args) SWIG_fail;
23320 swig_obj[0] = args;
23321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23322 if (!SWIG_IsOK(res1)) {
23323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23324 }
23325 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23326 result = (wxRect *)& ((arg1)->m_rect);
23327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23328 return resultobj;
23329 fail:
23330 return NULL;
23331 }
23332
23333
23334 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23335 PyObject *obj;
23336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23337 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23338 return SWIG_Py_Void();
23339 }
23340
23341 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23342 return SWIG_Python_InitShadowInstance(args);
23343 }
23344
23345 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23346 PyObject *resultobj = 0;
23347 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23348 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23349 int arg2 = (int) 0 ;
23350 wxMoveEvent *result = 0 ;
23351 wxPoint temp1 ;
23352 int val2 ;
23353 int ecode2 = 0 ;
23354 PyObject * obj0 = 0 ;
23355 PyObject * obj1 = 0 ;
23356 char * kwnames[] = {
23357 (char *) "pos",(char *) "winid", NULL
23358 };
23359
23360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23361 if (obj0) {
23362 {
23363 arg1 = &temp1;
23364 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23365 }
23366 }
23367 if (obj1) {
23368 ecode2 = SWIG_AsVal_int(obj1, &val2);
23369 if (!SWIG_IsOK(ecode2)) {
23370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23371 }
23372 arg2 = static_cast< int >(val2);
23373 }
23374 {
23375 PyThreadState* __tstate = wxPyBeginAllowThreads();
23376 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23377 wxPyEndAllowThreads(__tstate);
23378 if (PyErr_Occurred()) SWIG_fail;
23379 }
23380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23381 return resultobj;
23382 fail:
23383 return NULL;
23384 }
23385
23386
23387 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23388 PyObject *resultobj = 0;
23389 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23390 wxPoint result;
23391 void *argp1 = 0 ;
23392 int res1 = 0 ;
23393 PyObject *swig_obj[1] ;
23394
23395 if (!args) SWIG_fail;
23396 swig_obj[0] = args;
23397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23398 if (!SWIG_IsOK(res1)) {
23399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23400 }
23401 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23402 {
23403 PyThreadState* __tstate = wxPyBeginAllowThreads();
23404 result = ((wxMoveEvent const *)arg1)->GetPosition();
23405 wxPyEndAllowThreads(__tstate);
23406 if (PyErr_Occurred()) SWIG_fail;
23407 }
23408 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23409 return resultobj;
23410 fail:
23411 return NULL;
23412 }
23413
23414
23415 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23416 PyObject *resultobj = 0;
23417 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23418 wxRect result;
23419 void *argp1 = 0 ;
23420 int res1 = 0 ;
23421 PyObject *swig_obj[1] ;
23422
23423 if (!args) SWIG_fail;
23424 swig_obj[0] = args;
23425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23426 if (!SWIG_IsOK(res1)) {
23427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23428 }
23429 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23430 {
23431 PyThreadState* __tstate = wxPyBeginAllowThreads();
23432 result = ((wxMoveEvent const *)arg1)->GetRect();
23433 wxPyEndAllowThreads(__tstate);
23434 if (PyErr_Occurred()) SWIG_fail;
23435 }
23436 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23437 return resultobj;
23438 fail:
23439 return NULL;
23440 }
23441
23442
23443 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23444 PyObject *resultobj = 0;
23445 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23446 wxRect *arg2 = 0 ;
23447 void *argp1 = 0 ;
23448 int res1 = 0 ;
23449 wxRect temp2 ;
23450 PyObject * obj0 = 0 ;
23451 PyObject * obj1 = 0 ;
23452 char * kwnames[] = {
23453 (char *) "self",(char *) "rect", NULL
23454 };
23455
23456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23458 if (!SWIG_IsOK(res1)) {
23459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23460 }
23461 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23462 {
23463 arg2 = &temp2;
23464 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23465 }
23466 {
23467 PyThreadState* __tstate = wxPyBeginAllowThreads();
23468 (arg1)->SetRect((wxRect const &)*arg2);
23469 wxPyEndAllowThreads(__tstate);
23470 if (PyErr_Occurred()) SWIG_fail;
23471 }
23472 resultobj = SWIG_Py_Void();
23473 return resultobj;
23474 fail:
23475 return NULL;
23476 }
23477
23478
23479 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23480 PyObject *resultobj = 0;
23481 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23482 wxPoint *arg2 = 0 ;
23483 void *argp1 = 0 ;
23484 int res1 = 0 ;
23485 wxPoint temp2 ;
23486 PyObject * obj0 = 0 ;
23487 PyObject * obj1 = 0 ;
23488 char * kwnames[] = {
23489 (char *) "self",(char *) "pos", NULL
23490 };
23491
23492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23494 if (!SWIG_IsOK(res1)) {
23495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23496 }
23497 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23498 {
23499 arg2 = &temp2;
23500 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23501 }
23502 {
23503 PyThreadState* __tstate = wxPyBeginAllowThreads();
23504 (arg1)->SetPosition((wxPoint const &)*arg2);
23505 wxPyEndAllowThreads(__tstate);
23506 if (PyErr_Occurred()) SWIG_fail;
23507 }
23508 resultobj = SWIG_Py_Void();
23509 return resultobj;
23510 fail:
23511 return NULL;
23512 }
23513
23514
23515 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23516 PyObject *obj;
23517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23518 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23519 return SWIG_Py_Void();
23520 }
23521
23522 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23523 return SWIG_Python_InitShadowInstance(args);
23524 }
23525
23526 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23527 PyObject *resultobj = 0;
23528 int arg1 = (int) 0 ;
23529 wxPaintEvent *result = 0 ;
23530 int val1 ;
23531 int ecode1 = 0 ;
23532 PyObject * obj0 = 0 ;
23533 char * kwnames[] = {
23534 (char *) "Id", NULL
23535 };
23536
23537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23538 if (obj0) {
23539 ecode1 = SWIG_AsVal_int(obj0, &val1);
23540 if (!SWIG_IsOK(ecode1)) {
23541 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23542 }
23543 arg1 = static_cast< int >(val1);
23544 }
23545 {
23546 PyThreadState* __tstate = wxPyBeginAllowThreads();
23547 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23548 wxPyEndAllowThreads(__tstate);
23549 if (PyErr_Occurred()) SWIG_fail;
23550 }
23551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23552 return resultobj;
23553 fail:
23554 return NULL;
23555 }
23556
23557
23558 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23559 PyObject *obj;
23560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23561 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23562 return SWIG_Py_Void();
23563 }
23564
23565 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23566 return SWIG_Python_InitShadowInstance(args);
23567 }
23568
23569 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23570 PyObject *resultobj = 0;
23571 int arg1 = (int) 0 ;
23572 wxNcPaintEvent *result = 0 ;
23573 int val1 ;
23574 int ecode1 = 0 ;
23575 PyObject * obj0 = 0 ;
23576 char * kwnames[] = {
23577 (char *) "winid", NULL
23578 };
23579
23580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23581 if (obj0) {
23582 ecode1 = SWIG_AsVal_int(obj0, &val1);
23583 if (!SWIG_IsOK(ecode1)) {
23584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23585 }
23586 arg1 = static_cast< int >(val1);
23587 }
23588 {
23589 PyThreadState* __tstate = wxPyBeginAllowThreads();
23590 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23591 wxPyEndAllowThreads(__tstate);
23592 if (PyErr_Occurred()) SWIG_fail;
23593 }
23594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23595 return resultobj;
23596 fail:
23597 return NULL;
23598 }
23599
23600
23601 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23602 PyObject *obj;
23603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23604 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23605 return SWIG_Py_Void();
23606 }
23607
23608 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23609 return SWIG_Python_InitShadowInstance(args);
23610 }
23611
23612 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23613 PyObject *resultobj = 0;
23614 int arg1 = (int) 0 ;
23615 wxDC *arg2 = (wxDC *) NULL ;
23616 wxEraseEvent *result = 0 ;
23617 int val1 ;
23618 int ecode1 = 0 ;
23619 void *argp2 = 0 ;
23620 int res2 = 0 ;
23621 PyObject * obj0 = 0 ;
23622 PyObject * obj1 = 0 ;
23623 char * kwnames[] = {
23624 (char *) "Id",(char *) "dc", NULL
23625 };
23626
23627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23628 if (obj0) {
23629 ecode1 = SWIG_AsVal_int(obj0, &val1);
23630 if (!SWIG_IsOK(ecode1)) {
23631 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23632 }
23633 arg1 = static_cast< int >(val1);
23634 }
23635 if (obj1) {
23636 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23637 if (!SWIG_IsOK(res2)) {
23638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23639 }
23640 arg2 = reinterpret_cast< wxDC * >(argp2);
23641 }
23642 {
23643 PyThreadState* __tstate = wxPyBeginAllowThreads();
23644 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23645 wxPyEndAllowThreads(__tstate);
23646 if (PyErr_Occurred()) SWIG_fail;
23647 }
23648 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23649 return resultobj;
23650 fail:
23651 return NULL;
23652 }
23653
23654
23655 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23656 PyObject *resultobj = 0;
23657 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23658 wxDC *result = 0 ;
23659 void *argp1 = 0 ;
23660 int res1 = 0 ;
23661 PyObject *swig_obj[1] ;
23662
23663 if (!args) SWIG_fail;
23664 swig_obj[0] = args;
23665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23666 if (!SWIG_IsOK(res1)) {
23667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23668 }
23669 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23670 {
23671 PyThreadState* __tstate = wxPyBeginAllowThreads();
23672 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23673 wxPyEndAllowThreads(__tstate);
23674 if (PyErr_Occurred()) SWIG_fail;
23675 }
23676 {
23677 resultobj = wxPyMake_wxObject(result, (bool)0);
23678 }
23679 return resultobj;
23680 fail:
23681 return NULL;
23682 }
23683
23684
23685 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23686 PyObject *obj;
23687 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23688 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23689 return SWIG_Py_Void();
23690 }
23691
23692 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23693 return SWIG_Python_InitShadowInstance(args);
23694 }
23695
23696 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23697 PyObject *resultobj = 0;
23698 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23699 int arg2 = (int) 0 ;
23700 wxFocusEvent *result = 0 ;
23701 int val1 ;
23702 int ecode1 = 0 ;
23703 int val2 ;
23704 int ecode2 = 0 ;
23705 PyObject * obj0 = 0 ;
23706 PyObject * obj1 = 0 ;
23707 char * kwnames[] = {
23708 (char *) "type",(char *) "winid", NULL
23709 };
23710
23711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23712 if (obj0) {
23713 ecode1 = SWIG_AsVal_int(obj0, &val1);
23714 if (!SWIG_IsOK(ecode1)) {
23715 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23716 }
23717 arg1 = static_cast< wxEventType >(val1);
23718 }
23719 if (obj1) {
23720 ecode2 = SWIG_AsVal_int(obj1, &val2);
23721 if (!SWIG_IsOK(ecode2)) {
23722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23723 }
23724 arg2 = static_cast< int >(val2);
23725 }
23726 {
23727 PyThreadState* __tstate = wxPyBeginAllowThreads();
23728 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23729 wxPyEndAllowThreads(__tstate);
23730 if (PyErr_Occurred()) SWIG_fail;
23731 }
23732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23733 return resultobj;
23734 fail:
23735 return NULL;
23736 }
23737
23738
23739 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23740 PyObject *resultobj = 0;
23741 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23742 wxWindow *result = 0 ;
23743 void *argp1 = 0 ;
23744 int res1 = 0 ;
23745 PyObject *swig_obj[1] ;
23746
23747 if (!args) SWIG_fail;
23748 swig_obj[0] = args;
23749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23750 if (!SWIG_IsOK(res1)) {
23751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23752 }
23753 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23754 {
23755 PyThreadState* __tstate = wxPyBeginAllowThreads();
23756 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23757 wxPyEndAllowThreads(__tstate);
23758 if (PyErr_Occurred()) SWIG_fail;
23759 }
23760 {
23761 resultobj = wxPyMake_wxObject(result, (bool)0);
23762 }
23763 return resultobj;
23764 fail:
23765 return NULL;
23766 }
23767
23768
23769 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23770 PyObject *resultobj = 0;
23771 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23772 wxWindow *arg2 = (wxWindow *) 0 ;
23773 void *argp1 = 0 ;
23774 int res1 = 0 ;
23775 void *argp2 = 0 ;
23776 int res2 = 0 ;
23777 PyObject * obj0 = 0 ;
23778 PyObject * obj1 = 0 ;
23779 char * kwnames[] = {
23780 (char *) "self",(char *) "win", NULL
23781 };
23782
23783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23785 if (!SWIG_IsOK(res1)) {
23786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23787 }
23788 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23789 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23790 if (!SWIG_IsOK(res2)) {
23791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23792 }
23793 arg2 = reinterpret_cast< wxWindow * >(argp2);
23794 {
23795 PyThreadState* __tstate = wxPyBeginAllowThreads();
23796 (arg1)->SetWindow(arg2);
23797 wxPyEndAllowThreads(__tstate);
23798 if (PyErr_Occurred()) SWIG_fail;
23799 }
23800 resultobj = SWIG_Py_Void();
23801 return resultobj;
23802 fail:
23803 return NULL;
23804 }
23805
23806
23807 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23808 PyObject *obj;
23809 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23810 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23811 return SWIG_Py_Void();
23812 }
23813
23814 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23815 return SWIG_Python_InitShadowInstance(args);
23816 }
23817
23818 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23819 PyObject *resultobj = 0;
23820 wxWindow *arg1 = (wxWindow *) NULL ;
23821 wxChildFocusEvent *result = 0 ;
23822 void *argp1 = 0 ;
23823 int res1 = 0 ;
23824 PyObject * obj0 = 0 ;
23825 char * kwnames[] = {
23826 (char *) "win", NULL
23827 };
23828
23829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23830 if (obj0) {
23831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23832 if (!SWIG_IsOK(res1)) {
23833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23834 }
23835 arg1 = reinterpret_cast< wxWindow * >(argp1);
23836 }
23837 {
23838 PyThreadState* __tstate = wxPyBeginAllowThreads();
23839 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23840 wxPyEndAllowThreads(__tstate);
23841 if (PyErr_Occurred()) SWIG_fail;
23842 }
23843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23844 return resultobj;
23845 fail:
23846 return NULL;
23847 }
23848
23849
23850 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23851 PyObject *resultobj = 0;
23852 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23853 wxWindow *result = 0 ;
23854 void *argp1 = 0 ;
23855 int res1 = 0 ;
23856 PyObject *swig_obj[1] ;
23857
23858 if (!args) SWIG_fail;
23859 swig_obj[0] = args;
23860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23861 if (!SWIG_IsOK(res1)) {
23862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23863 }
23864 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23865 {
23866 PyThreadState* __tstate = wxPyBeginAllowThreads();
23867 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23868 wxPyEndAllowThreads(__tstate);
23869 if (PyErr_Occurred()) SWIG_fail;
23870 }
23871 {
23872 resultobj = wxPyMake_wxObject(result, (bool)0);
23873 }
23874 return resultobj;
23875 fail:
23876 return NULL;
23877 }
23878
23879
23880 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23881 PyObject *obj;
23882 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23883 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23884 return SWIG_Py_Void();
23885 }
23886
23887 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23888 return SWIG_Python_InitShadowInstance(args);
23889 }
23890
23891 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23892 PyObject *resultobj = 0;
23893 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23894 bool arg2 = (bool) true ;
23895 int arg3 = (int) 0 ;
23896 wxActivateEvent *result = 0 ;
23897 int val1 ;
23898 int ecode1 = 0 ;
23899 bool val2 ;
23900 int ecode2 = 0 ;
23901 int val3 ;
23902 int ecode3 = 0 ;
23903 PyObject * obj0 = 0 ;
23904 PyObject * obj1 = 0 ;
23905 PyObject * obj2 = 0 ;
23906 char * kwnames[] = {
23907 (char *) "type",(char *) "active",(char *) "Id", NULL
23908 };
23909
23910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23911 if (obj0) {
23912 ecode1 = SWIG_AsVal_int(obj0, &val1);
23913 if (!SWIG_IsOK(ecode1)) {
23914 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23915 }
23916 arg1 = static_cast< wxEventType >(val1);
23917 }
23918 if (obj1) {
23919 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23920 if (!SWIG_IsOK(ecode2)) {
23921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23922 }
23923 arg2 = static_cast< bool >(val2);
23924 }
23925 if (obj2) {
23926 ecode3 = SWIG_AsVal_int(obj2, &val3);
23927 if (!SWIG_IsOK(ecode3)) {
23928 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23929 }
23930 arg3 = static_cast< int >(val3);
23931 }
23932 {
23933 PyThreadState* __tstate = wxPyBeginAllowThreads();
23934 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23935 wxPyEndAllowThreads(__tstate);
23936 if (PyErr_Occurred()) SWIG_fail;
23937 }
23938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23939 return resultobj;
23940 fail:
23941 return NULL;
23942 }
23943
23944
23945 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23946 PyObject *resultobj = 0;
23947 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23948 bool result;
23949 void *argp1 = 0 ;
23950 int res1 = 0 ;
23951 PyObject *swig_obj[1] ;
23952
23953 if (!args) SWIG_fail;
23954 swig_obj[0] = args;
23955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23956 if (!SWIG_IsOK(res1)) {
23957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23958 }
23959 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23960 {
23961 PyThreadState* __tstate = wxPyBeginAllowThreads();
23962 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23963 wxPyEndAllowThreads(__tstate);
23964 if (PyErr_Occurred()) SWIG_fail;
23965 }
23966 {
23967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23968 }
23969 return resultobj;
23970 fail:
23971 return NULL;
23972 }
23973
23974
23975 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23976 PyObject *obj;
23977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23978 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23979 return SWIG_Py_Void();
23980 }
23981
23982 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23983 return SWIG_Python_InitShadowInstance(args);
23984 }
23985
23986 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23987 PyObject *resultobj = 0;
23988 int arg1 = (int) 0 ;
23989 wxInitDialogEvent *result = 0 ;
23990 int val1 ;
23991 int ecode1 = 0 ;
23992 PyObject * obj0 = 0 ;
23993 char * kwnames[] = {
23994 (char *) "Id", NULL
23995 };
23996
23997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23998 if (obj0) {
23999 ecode1 = SWIG_AsVal_int(obj0, &val1);
24000 if (!SWIG_IsOK(ecode1)) {
24001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24002 }
24003 arg1 = static_cast< int >(val1);
24004 }
24005 {
24006 PyThreadState* __tstate = wxPyBeginAllowThreads();
24007 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24008 wxPyEndAllowThreads(__tstate);
24009 if (PyErr_Occurred()) SWIG_fail;
24010 }
24011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24012 return resultobj;
24013 fail:
24014 return NULL;
24015 }
24016
24017
24018 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24019 PyObject *obj;
24020 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24021 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24022 return SWIG_Py_Void();
24023 }
24024
24025 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24026 return SWIG_Python_InitShadowInstance(args);
24027 }
24028
24029 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24030 PyObject *resultobj = 0;
24031 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24032 int arg2 = (int) 0 ;
24033 wxMenu *arg3 = (wxMenu *) NULL ;
24034 wxMenuEvent *result = 0 ;
24035 int val1 ;
24036 int ecode1 = 0 ;
24037 int val2 ;
24038 int ecode2 = 0 ;
24039 void *argp3 = 0 ;
24040 int res3 = 0 ;
24041 PyObject * obj0 = 0 ;
24042 PyObject * obj1 = 0 ;
24043 PyObject * obj2 = 0 ;
24044 char * kwnames[] = {
24045 (char *) "type",(char *) "winid",(char *) "menu", NULL
24046 };
24047
24048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24049 if (obj0) {
24050 ecode1 = SWIG_AsVal_int(obj0, &val1);
24051 if (!SWIG_IsOK(ecode1)) {
24052 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24053 }
24054 arg1 = static_cast< wxEventType >(val1);
24055 }
24056 if (obj1) {
24057 ecode2 = SWIG_AsVal_int(obj1, &val2);
24058 if (!SWIG_IsOK(ecode2)) {
24059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24060 }
24061 arg2 = static_cast< int >(val2);
24062 }
24063 if (obj2) {
24064 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24065 if (!SWIG_IsOK(res3)) {
24066 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24067 }
24068 arg3 = reinterpret_cast< wxMenu * >(argp3);
24069 }
24070 {
24071 PyThreadState* __tstate = wxPyBeginAllowThreads();
24072 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24073 wxPyEndAllowThreads(__tstate);
24074 if (PyErr_Occurred()) SWIG_fail;
24075 }
24076 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24077 return resultobj;
24078 fail:
24079 return NULL;
24080 }
24081
24082
24083 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24084 PyObject *resultobj = 0;
24085 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24086 int result;
24087 void *argp1 = 0 ;
24088 int res1 = 0 ;
24089 PyObject *swig_obj[1] ;
24090
24091 if (!args) SWIG_fail;
24092 swig_obj[0] = args;
24093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24094 if (!SWIG_IsOK(res1)) {
24095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24096 }
24097 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24098 {
24099 PyThreadState* __tstate = wxPyBeginAllowThreads();
24100 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24101 wxPyEndAllowThreads(__tstate);
24102 if (PyErr_Occurred()) SWIG_fail;
24103 }
24104 resultobj = SWIG_From_int(static_cast< int >(result));
24105 return resultobj;
24106 fail:
24107 return NULL;
24108 }
24109
24110
24111 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24112 PyObject *resultobj = 0;
24113 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24114 bool result;
24115 void *argp1 = 0 ;
24116 int res1 = 0 ;
24117 PyObject *swig_obj[1] ;
24118
24119 if (!args) SWIG_fail;
24120 swig_obj[0] = args;
24121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24122 if (!SWIG_IsOK(res1)) {
24123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24124 }
24125 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24126 {
24127 PyThreadState* __tstate = wxPyBeginAllowThreads();
24128 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24129 wxPyEndAllowThreads(__tstate);
24130 if (PyErr_Occurred()) SWIG_fail;
24131 }
24132 {
24133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24134 }
24135 return resultobj;
24136 fail:
24137 return NULL;
24138 }
24139
24140
24141 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24142 PyObject *resultobj = 0;
24143 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24144 wxMenu *result = 0 ;
24145 void *argp1 = 0 ;
24146 int res1 = 0 ;
24147 PyObject *swig_obj[1] ;
24148
24149 if (!args) SWIG_fail;
24150 swig_obj[0] = args;
24151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24152 if (!SWIG_IsOK(res1)) {
24153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24154 }
24155 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24156 {
24157 PyThreadState* __tstate = wxPyBeginAllowThreads();
24158 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24159 wxPyEndAllowThreads(__tstate);
24160 if (PyErr_Occurred()) SWIG_fail;
24161 }
24162 {
24163 resultobj = wxPyMake_wxObject(result, (bool)0);
24164 }
24165 return resultobj;
24166 fail:
24167 return NULL;
24168 }
24169
24170
24171 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24172 PyObject *obj;
24173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24174 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24175 return SWIG_Py_Void();
24176 }
24177
24178 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24179 return SWIG_Python_InitShadowInstance(args);
24180 }
24181
24182 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24183 PyObject *resultobj = 0;
24184 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24185 int arg2 = (int) 0 ;
24186 wxCloseEvent *result = 0 ;
24187 int val1 ;
24188 int ecode1 = 0 ;
24189 int val2 ;
24190 int ecode2 = 0 ;
24191 PyObject * obj0 = 0 ;
24192 PyObject * obj1 = 0 ;
24193 char * kwnames[] = {
24194 (char *) "type",(char *) "winid", NULL
24195 };
24196
24197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24198 if (obj0) {
24199 ecode1 = SWIG_AsVal_int(obj0, &val1);
24200 if (!SWIG_IsOK(ecode1)) {
24201 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24202 }
24203 arg1 = static_cast< wxEventType >(val1);
24204 }
24205 if (obj1) {
24206 ecode2 = SWIG_AsVal_int(obj1, &val2);
24207 if (!SWIG_IsOK(ecode2)) {
24208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24209 }
24210 arg2 = static_cast< int >(val2);
24211 }
24212 {
24213 PyThreadState* __tstate = wxPyBeginAllowThreads();
24214 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24215 wxPyEndAllowThreads(__tstate);
24216 if (PyErr_Occurred()) SWIG_fail;
24217 }
24218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24219 return resultobj;
24220 fail:
24221 return NULL;
24222 }
24223
24224
24225 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24226 PyObject *resultobj = 0;
24227 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24228 bool arg2 ;
24229 void *argp1 = 0 ;
24230 int res1 = 0 ;
24231 bool val2 ;
24232 int ecode2 = 0 ;
24233 PyObject * obj0 = 0 ;
24234 PyObject * obj1 = 0 ;
24235 char * kwnames[] = {
24236 (char *) "self",(char *) "logOff", NULL
24237 };
24238
24239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24241 if (!SWIG_IsOK(res1)) {
24242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24243 }
24244 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24245 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24246 if (!SWIG_IsOK(ecode2)) {
24247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24248 }
24249 arg2 = static_cast< bool >(val2);
24250 {
24251 PyThreadState* __tstate = wxPyBeginAllowThreads();
24252 (arg1)->SetLoggingOff(arg2);
24253 wxPyEndAllowThreads(__tstate);
24254 if (PyErr_Occurred()) SWIG_fail;
24255 }
24256 resultobj = SWIG_Py_Void();
24257 return resultobj;
24258 fail:
24259 return NULL;
24260 }
24261
24262
24263 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24264 PyObject *resultobj = 0;
24265 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24266 bool result;
24267 void *argp1 = 0 ;
24268 int res1 = 0 ;
24269 PyObject *swig_obj[1] ;
24270
24271 if (!args) SWIG_fail;
24272 swig_obj[0] = args;
24273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24274 if (!SWIG_IsOK(res1)) {
24275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24276 }
24277 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24278 {
24279 PyThreadState* __tstate = wxPyBeginAllowThreads();
24280 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24281 wxPyEndAllowThreads(__tstate);
24282 if (PyErr_Occurred()) SWIG_fail;
24283 }
24284 {
24285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24286 }
24287 return resultobj;
24288 fail:
24289 return NULL;
24290 }
24291
24292
24293 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24294 PyObject *resultobj = 0;
24295 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24296 bool arg2 = (bool) true ;
24297 void *argp1 = 0 ;
24298 int res1 = 0 ;
24299 bool val2 ;
24300 int ecode2 = 0 ;
24301 PyObject * obj0 = 0 ;
24302 PyObject * obj1 = 0 ;
24303 char * kwnames[] = {
24304 (char *) "self",(char *) "veto", NULL
24305 };
24306
24307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24309 if (!SWIG_IsOK(res1)) {
24310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24311 }
24312 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24313 if (obj1) {
24314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24315 if (!SWIG_IsOK(ecode2)) {
24316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24317 }
24318 arg2 = static_cast< bool >(val2);
24319 }
24320 {
24321 PyThreadState* __tstate = wxPyBeginAllowThreads();
24322 (arg1)->Veto(arg2);
24323 wxPyEndAllowThreads(__tstate);
24324 if (PyErr_Occurred()) SWIG_fail;
24325 }
24326 resultobj = SWIG_Py_Void();
24327 return resultobj;
24328 fail:
24329 return NULL;
24330 }
24331
24332
24333 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24334 PyObject *resultobj = 0;
24335 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24336 bool result;
24337 void *argp1 = 0 ;
24338 int res1 = 0 ;
24339 PyObject *swig_obj[1] ;
24340
24341 if (!args) SWIG_fail;
24342 swig_obj[0] = args;
24343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24344 if (!SWIG_IsOK(res1)) {
24345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24346 }
24347 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24348 {
24349 PyThreadState* __tstate = wxPyBeginAllowThreads();
24350 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24351 wxPyEndAllowThreads(__tstate);
24352 if (PyErr_Occurred()) SWIG_fail;
24353 }
24354 {
24355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24356 }
24357 return resultobj;
24358 fail:
24359 return NULL;
24360 }
24361
24362
24363 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24364 PyObject *resultobj = 0;
24365 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24366 bool arg2 ;
24367 void *argp1 = 0 ;
24368 int res1 = 0 ;
24369 bool val2 ;
24370 int ecode2 = 0 ;
24371 PyObject * obj0 = 0 ;
24372 PyObject * obj1 = 0 ;
24373 char * kwnames[] = {
24374 (char *) "self",(char *) "canVeto", NULL
24375 };
24376
24377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24379 if (!SWIG_IsOK(res1)) {
24380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24381 }
24382 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24383 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24384 if (!SWIG_IsOK(ecode2)) {
24385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24386 }
24387 arg2 = static_cast< bool >(val2);
24388 {
24389 PyThreadState* __tstate = wxPyBeginAllowThreads();
24390 (arg1)->SetCanVeto(arg2);
24391 wxPyEndAllowThreads(__tstate);
24392 if (PyErr_Occurred()) SWIG_fail;
24393 }
24394 resultobj = SWIG_Py_Void();
24395 return resultobj;
24396 fail:
24397 return NULL;
24398 }
24399
24400
24401 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24402 PyObject *resultobj = 0;
24403 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24404 bool result;
24405 void *argp1 = 0 ;
24406 int res1 = 0 ;
24407 PyObject *swig_obj[1] ;
24408
24409 if (!args) SWIG_fail;
24410 swig_obj[0] = args;
24411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24412 if (!SWIG_IsOK(res1)) {
24413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24414 }
24415 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24416 {
24417 PyThreadState* __tstate = wxPyBeginAllowThreads();
24418 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24419 wxPyEndAllowThreads(__tstate);
24420 if (PyErr_Occurred()) SWIG_fail;
24421 }
24422 {
24423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24424 }
24425 return resultobj;
24426 fail:
24427 return NULL;
24428 }
24429
24430
24431 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24432 PyObject *obj;
24433 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24434 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24435 return SWIG_Py_Void();
24436 }
24437
24438 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24439 return SWIG_Python_InitShadowInstance(args);
24440 }
24441
24442 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24443 PyObject *resultobj = 0;
24444 int arg1 = (int) 0 ;
24445 bool arg2 = (bool) false ;
24446 wxShowEvent *result = 0 ;
24447 int val1 ;
24448 int ecode1 = 0 ;
24449 bool val2 ;
24450 int ecode2 = 0 ;
24451 PyObject * obj0 = 0 ;
24452 PyObject * obj1 = 0 ;
24453 char * kwnames[] = {
24454 (char *) "winid",(char *) "show", NULL
24455 };
24456
24457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24458 if (obj0) {
24459 ecode1 = SWIG_AsVal_int(obj0, &val1);
24460 if (!SWIG_IsOK(ecode1)) {
24461 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24462 }
24463 arg1 = static_cast< int >(val1);
24464 }
24465 if (obj1) {
24466 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24467 if (!SWIG_IsOK(ecode2)) {
24468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24469 }
24470 arg2 = static_cast< bool >(val2);
24471 }
24472 {
24473 PyThreadState* __tstate = wxPyBeginAllowThreads();
24474 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24475 wxPyEndAllowThreads(__tstate);
24476 if (PyErr_Occurred()) SWIG_fail;
24477 }
24478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24479 return resultobj;
24480 fail:
24481 return NULL;
24482 }
24483
24484
24485 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24486 PyObject *resultobj = 0;
24487 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24488 bool arg2 ;
24489 void *argp1 = 0 ;
24490 int res1 = 0 ;
24491 bool val2 ;
24492 int ecode2 = 0 ;
24493 PyObject * obj0 = 0 ;
24494 PyObject * obj1 = 0 ;
24495 char * kwnames[] = {
24496 (char *) "self",(char *) "show", NULL
24497 };
24498
24499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24501 if (!SWIG_IsOK(res1)) {
24502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24503 }
24504 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24505 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24506 if (!SWIG_IsOK(ecode2)) {
24507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24508 }
24509 arg2 = static_cast< bool >(val2);
24510 {
24511 PyThreadState* __tstate = wxPyBeginAllowThreads();
24512 (arg1)->SetShow(arg2);
24513 wxPyEndAllowThreads(__tstate);
24514 if (PyErr_Occurred()) SWIG_fail;
24515 }
24516 resultobj = SWIG_Py_Void();
24517 return resultobj;
24518 fail:
24519 return NULL;
24520 }
24521
24522
24523 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24524 PyObject *resultobj = 0;
24525 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24526 bool result;
24527 void *argp1 = 0 ;
24528 int res1 = 0 ;
24529 PyObject *swig_obj[1] ;
24530
24531 if (!args) SWIG_fail;
24532 swig_obj[0] = args;
24533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24534 if (!SWIG_IsOK(res1)) {
24535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24536 }
24537 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24538 {
24539 PyThreadState* __tstate = wxPyBeginAllowThreads();
24540 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24541 wxPyEndAllowThreads(__tstate);
24542 if (PyErr_Occurred()) SWIG_fail;
24543 }
24544 {
24545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24546 }
24547 return resultobj;
24548 fail:
24549 return NULL;
24550 }
24551
24552
24553 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24554 PyObject *obj;
24555 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24556 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24557 return SWIG_Py_Void();
24558 }
24559
24560 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24561 return SWIG_Python_InitShadowInstance(args);
24562 }
24563
24564 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24565 PyObject *resultobj = 0;
24566 int arg1 = (int) 0 ;
24567 bool arg2 = (bool) true ;
24568 wxIconizeEvent *result = 0 ;
24569 int val1 ;
24570 int ecode1 = 0 ;
24571 bool val2 ;
24572 int ecode2 = 0 ;
24573 PyObject * obj0 = 0 ;
24574 PyObject * obj1 = 0 ;
24575 char * kwnames[] = {
24576 (char *) "id",(char *) "iconized", NULL
24577 };
24578
24579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24580 if (obj0) {
24581 ecode1 = SWIG_AsVal_int(obj0, &val1);
24582 if (!SWIG_IsOK(ecode1)) {
24583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24584 }
24585 arg1 = static_cast< int >(val1);
24586 }
24587 if (obj1) {
24588 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24589 if (!SWIG_IsOK(ecode2)) {
24590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24591 }
24592 arg2 = static_cast< bool >(val2);
24593 }
24594 {
24595 PyThreadState* __tstate = wxPyBeginAllowThreads();
24596 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24597 wxPyEndAllowThreads(__tstate);
24598 if (PyErr_Occurred()) SWIG_fail;
24599 }
24600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24601 return resultobj;
24602 fail:
24603 return NULL;
24604 }
24605
24606
24607 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24608 PyObject *resultobj = 0;
24609 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24610 bool result;
24611 void *argp1 = 0 ;
24612 int res1 = 0 ;
24613 PyObject *swig_obj[1] ;
24614
24615 if (!args) SWIG_fail;
24616 swig_obj[0] = args;
24617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24618 if (!SWIG_IsOK(res1)) {
24619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24620 }
24621 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24622 {
24623 PyThreadState* __tstate = wxPyBeginAllowThreads();
24624 result = (bool)(arg1)->Iconized();
24625 wxPyEndAllowThreads(__tstate);
24626 if (PyErr_Occurred()) SWIG_fail;
24627 }
24628 {
24629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24630 }
24631 return resultobj;
24632 fail:
24633 return NULL;
24634 }
24635
24636
24637 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24638 PyObject *obj;
24639 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24640 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24641 return SWIG_Py_Void();
24642 }
24643
24644 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24645 return SWIG_Python_InitShadowInstance(args);
24646 }
24647
24648 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24649 PyObject *resultobj = 0;
24650 int arg1 = (int) 0 ;
24651 wxMaximizeEvent *result = 0 ;
24652 int val1 ;
24653 int ecode1 = 0 ;
24654 PyObject * obj0 = 0 ;
24655 char * kwnames[] = {
24656 (char *) "id", NULL
24657 };
24658
24659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24660 if (obj0) {
24661 ecode1 = SWIG_AsVal_int(obj0, &val1);
24662 if (!SWIG_IsOK(ecode1)) {
24663 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24664 }
24665 arg1 = static_cast< int >(val1);
24666 }
24667 {
24668 PyThreadState* __tstate = wxPyBeginAllowThreads();
24669 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24670 wxPyEndAllowThreads(__tstate);
24671 if (PyErr_Occurred()) SWIG_fail;
24672 }
24673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24674 return resultobj;
24675 fail:
24676 return NULL;
24677 }
24678
24679
24680 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24681 PyObject *obj;
24682 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24683 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24684 return SWIG_Py_Void();
24685 }
24686
24687 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24688 return SWIG_Python_InitShadowInstance(args);
24689 }
24690
24691 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24692 PyObject *resultobj = 0;
24693 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24694 wxPoint result;
24695 void *argp1 = 0 ;
24696 int res1 = 0 ;
24697 PyObject *swig_obj[1] ;
24698
24699 if (!args) SWIG_fail;
24700 swig_obj[0] = args;
24701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24702 if (!SWIG_IsOK(res1)) {
24703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24704 }
24705 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24706 {
24707 PyThreadState* __tstate = wxPyBeginAllowThreads();
24708 result = (arg1)->GetPosition();
24709 wxPyEndAllowThreads(__tstate);
24710 if (PyErr_Occurred()) SWIG_fail;
24711 }
24712 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24713 return resultobj;
24714 fail:
24715 return NULL;
24716 }
24717
24718
24719 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24720 PyObject *resultobj = 0;
24721 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24722 int result;
24723 void *argp1 = 0 ;
24724 int res1 = 0 ;
24725 PyObject *swig_obj[1] ;
24726
24727 if (!args) SWIG_fail;
24728 swig_obj[0] = args;
24729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24730 if (!SWIG_IsOK(res1)) {
24731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24732 }
24733 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24734 {
24735 PyThreadState* __tstate = wxPyBeginAllowThreads();
24736 result = (int)(arg1)->GetNumberOfFiles();
24737 wxPyEndAllowThreads(__tstate);
24738 if (PyErr_Occurred()) SWIG_fail;
24739 }
24740 resultobj = SWIG_From_int(static_cast< int >(result));
24741 return resultobj;
24742 fail:
24743 return NULL;
24744 }
24745
24746
24747 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24748 PyObject *resultobj = 0;
24749 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24750 PyObject *result = 0 ;
24751 void *argp1 = 0 ;
24752 int res1 = 0 ;
24753 PyObject *swig_obj[1] ;
24754
24755 if (!args) SWIG_fail;
24756 swig_obj[0] = args;
24757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24758 if (!SWIG_IsOK(res1)) {
24759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24760 }
24761 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24762 {
24763 PyThreadState* __tstate = wxPyBeginAllowThreads();
24764 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24765 wxPyEndAllowThreads(__tstate);
24766 if (PyErr_Occurred()) SWIG_fail;
24767 }
24768 resultobj = result;
24769 return resultobj;
24770 fail:
24771 return NULL;
24772 }
24773
24774
24775 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24776 PyObject *obj;
24777 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24778 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24779 return SWIG_Py_Void();
24780 }
24781
24782 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24783 PyObject *resultobj = 0;
24784 int arg1 = (int) 0 ;
24785 wxUpdateUIEvent *result = 0 ;
24786 int val1 ;
24787 int ecode1 = 0 ;
24788 PyObject * obj0 = 0 ;
24789 char * kwnames[] = {
24790 (char *) "commandId", NULL
24791 };
24792
24793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24794 if (obj0) {
24795 ecode1 = SWIG_AsVal_int(obj0, &val1);
24796 if (!SWIG_IsOK(ecode1)) {
24797 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24798 }
24799 arg1 = static_cast< int >(val1);
24800 }
24801 {
24802 PyThreadState* __tstate = wxPyBeginAllowThreads();
24803 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24804 wxPyEndAllowThreads(__tstate);
24805 if (PyErr_Occurred()) SWIG_fail;
24806 }
24807 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24808 return resultobj;
24809 fail:
24810 return NULL;
24811 }
24812
24813
24814 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24815 PyObject *resultobj = 0;
24816 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24817 bool result;
24818 void *argp1 = 0 ;
24819 int res1 = 0 ;
24820 PyObject *swig_obj[1] ;
24821
24822 if (!args) SWIG_fail;
24823 swig_obj[0] = args;
24824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24825 if (!SWIG_IsOK(res1)) {
24826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24827 }
24828 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24829 {
24830 PyThreadState* __tstate = wxPyBeginAllowThreads();
24831 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24832 wxPyEndAllowThreads(__tstate);
24833 if (PyErr_Occurred()) SWIG_fail;
24834 }
24835 {
24836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24837 }
24838 return resultobj;
24839 fail:
24840 return NULL;
24841 }
24842
24843
24844 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24845 PyObject *resultobj = 0;
24846 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24847 bool result;
24848 void *argp1 = 0 ;
24849 int res1 = 0 ;
24850 PyObject *swig_obj[1] ;
24851
24852 if (!args) SWIG_fail;
24853 swig_obj[0] = args;
24854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24855 if (!SWIG_IsOK(res1)) {
24856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24857 }
24858 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24859 {
24860 PyThreadState* __tstate = wxPyBeginAllowThreads();
24861 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24862 wxPyEndAllowThreads(__tstate);
24863 if (PyErr_Occurred()) SWIG_fail;
24864 }
24865 {
24866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24867 }
24868 return resultobj;
24869 fail:
24870 return NULL;
24871 }
24872
24873
24874 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24875 PyObject *resultobj = 0;
24876 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24877 bool result;
24878 void *argp1 = 0 ;
24879 int res1 = 0 ;
24880 PyObject *swig_obj[1] ;
24881
24882 if (!args) SWIG_fail;
24883 swig_obj[0] = args;
24884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24885 if (!SWIG_IsOK(res1)) {
24886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24887 }
24888 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24889 {
24890 PyThreadState* __tstate = wxPyBeginAllowThreads();
24891 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24892 wxPyEndAllowThreads(__tstate);
24893 if (PyErr_Occurred()) SWIG_fail;
24894 }
24895 {
24896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24897 }
24898 return resultobj;
24899 fail:
24900 return NULL;
24901 }
24902
24903
24904 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24905 PyObject *resultobj = 0;
24906 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24907 wxString result;
24908 void *argp1 = 0 ;
24909 int res1 = 0 ;
24910 PyObject *swig_obj[1] ;
24911
24912 if (!args) SWIG_fail;
24913 swig_obj[0] = args;
24914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24915 if (!SWIG_IsOK(res1)) {
24916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24917 }
24918 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24919 {
24920 PyThreadState* __tstate = wxPyBeginAllowThreads();
24921 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24922 wxPyEndAllowThreads(__tstate);
24923 if (PyErr_Occurred()) SWIG_fail;
24924 }
24925 {
24926 #if wxUSE_UNICODE
24927 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24928 #else
24929 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24930 #endif
24931 }
24932 return resultobj;
24933 fail:
24934 return NULL;
24935 }
24936
24937
24938 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24939 PyObject *resultobj = 0;
24940 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24941 bool result;
24942 void *argp1 = 0 ;
24943 int res1 = 0 ;
24944 PyObject *swig_obj[1] ;
24945
24946 if (!args) SWIG_fail;
24947 swig_obj[0] = args;
24948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24949 if (!SWIG_IsOK(res1)) {
24950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24951 }
24952 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24953 {
24954 PyThreadState* __tstate = wxPyBeginAllowThreads();
24955 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24956 wxPyEndAllowThreads(__tstate);
24957 if (PyErr_Occurred()) SWIG_fail;
24958 }
24959 {
24960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24961 }
24962 return resultobj;
24963 fail:
24964 return NULL;
24965 }
24966
24967
24968 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24969 PyObject *resultobj = 0;
24970 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24971 bool result;
24972 void *argp1 = 0 ;
24973 int res1 = 0 ;
24974 PyObject *swig_obj[1] ;
24975
24976 if (!args) SWIG_fail;
24977 swig_obj[0] = args;
24978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24979 if (!SWIG_IsOK(res1)) {
24980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24981 }
24982 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24983 {
24984 PyThreadState* __tstate = wxPyBeginAllowThreads();
24985 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24986 wxPyEndAllowThreads(__tstate);
24987 if (PyErr_Occurred()) SWIG_fail;
24988 }
24989 {
24990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24991 }
24992 return resultobj;
24993 fail:
24994 return NULL;
24995 }
24996
24997
24998 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24999 PyObject *resultobj = 0;
25000 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25001 bool result;
25002 void *argp1 = 0 ;
25003 int res1 = 0 ;
25004 PyObject *swig_obj[1] ;
25005
25006 if (!args) SWIG_fail;
25007 swig_obj[0] = args;
25008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25009 if (!SWIG_IsOK(res1)) {
25010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25011 }
25012 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25013 {
25014 PyThreadState* __tstate = wxPyBeginAllowThreads();
25015 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25016 wxPyEndAllowThreads(__tstate);
25017 if (PyErr_Occurred()) SWIG_fail;
25018 }
25019 {
25020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25021 }
25022 return resultobj;
25023 fail:
25024 return NULL;
25025 }
25026
25027
25028 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25029 PyObject *resultobj = 0;
25030 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25031 bool result;
25032 void *argp1 = 0 ;
25033 int res1 = 0 ;
25034 PyObject *swig_obj[1] ;
25035
25036 if (!args) SWIG_fail;
25037 swig_obj[0] = args;
25038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25039 if (!SWIG_IsOK(res1)) {
25040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25041 }
25042 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25043 {
25044 PyThreadState* __tstate = wxPyBeginAllowThreads();
25045 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25046 wxPyEndAllowThreads(__tstate);
25047 if (PyErr_Occurred()) SWIG_fail;
25048 }
25049 {
25050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25051 }
25052 return resultobj;
25053 fail:
25054 return NULL;
25055 }
25056
25057
25058 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25059 PyObject *resultobj = 0;
25060 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25061 bool arg2 ;
25062 void *argp1 = 0 ;
25063 int res1 = 0 ;
25064 bool val2 ;
25065 int ecode2 = 0 ;
25066 PyObject * obj0 = 0 ;
25067 PyObject * obj1 = 0 ;
25068 char * kwnames[] = {
25069 (char *) "self",(char *) "check", NULL
25070 };
25071
25072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25074 if (!SWIG_IsOK(res1)) {
25075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25076 }
25077 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25078 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25079 if (!SWIG_IsOK(ecode2)) {
25080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25081 }
25082 arg2 = static_cast< bool >(val2);
25083 {
25084 PyThreadState* __tstate = wxPyBeginAllowThreads();
25085 (arg1)->Check(arg2);
25086 wxPyEndAllowThreads(__tstate);
25087 if (PyErr_Occurred()) SWIG_fail;
25088 }
25089 resultobj = SWIG_Py_Void();
25090 return resultobj;
25091 fail:
25092 return NULL;
25093 }
25094
25095
25096 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25097 PyObject *resultobj = 0;
25098 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25099 bool arg2 ;
25100 void *argp1 = 0 ;
25101 int res1 = 0 ;
25102 bool val2 ;
25103 int ecode2 = 0 ;
25104 PyObject * obj0 = 0 ;
25105 PyObject * obj1 = 0 ;
25106 char * kwnames[] = {
25107 (char *) "self",(char *) "enable", NULL
25108 };
25109
25110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25112 if (!SWIG_IsOK(res1)) {
25113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25114 }
25115 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25116 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25117 if (!SWIG_IsOK(ecode2)) {
25118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25119 }
25120 arg2 = static_cast< bool >(val2);
25121 {
25122 PyThreadState* __tstate = wxPyBeginAllowThreads();
25123 (arg1)->Enable(arg2);
25124 wxPyEndAllowThreads(__tstate);
25125 if (PyErr_Occurred()) SWIG_fail;
25126 }
25127 resultobj = SWIG_Py_Void();
25128 return resultobj;
25129 fail:
25130 return NULL;
25131 }
25132
25133
25134 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25135 PyObject *resultobj = 0;
25136 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25137 bool arg2 ;
25138 void *argp1 = 0 ;
25139 int res1 = 0 ;
25140 bool val2 ;
25141 int ecode2 = 0 ;
25142 PyObject * obj0 = 0 ;
25143 PyObject * obj1 = 0 ;
25144 char * kwnames[] = {
25145 (char *) "self",(char *) "show", NULL
25146 };
25147
25148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25150 if (!SWIG_IsOK(res1)) {
25151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25152 }
25153 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25154 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25155 if (!SWIG_IsOK(ecode2)) {
25156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25157 }
25158 arg2 = static_cast< bool >(val2);
25159 {
25160 PyThreadState* __tstate = wxPyBeginAllowThreads();
25161 (arg1)->Show(arg2);
25162 wxPyEndAllowThreads(__tstate);
25163 if (PyErr_Occurred()) SWIG_fail;
25164 }
25165 resultobj = SWIG_Py_Void();
25166 return resultobj;
25167 fail:
25168 return NULL;
25169 }
25170
25171
25172 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25173 PyObject *resultobj = 0;
25174 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25175 wxString *arg2 = 0 ;
25176 void *argp1 = 0 ;
25177 int res1 = 0 ;
25178 bool temp2 = false ;
25179 PyObject * obj0 = 0 ;
25180 PyObject * obj1 = 0 ;
25181 char * kwnames[] = {
25182 (char *) "self",(char *) "text", NULL
25183 };
25184
25185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25187 if (!SWIG_IsOK(res1)) {
25188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25189 }
25190 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25191 {
25192 arg2 = wxString_in_helper(obj1);
25193 if (arg2 == NULL) SWIG_fail;
25194 temp2 = true;
25195 }
25196 {
25197 PyThreadState* __tstate = wxPyBeginAllowThreads();
25198 (arg1)->SetText((wxString const &)*arg2);
25199 wxPyEndAllowThreads(__tstate);
25200 if (PyErr_Occurred()) SWIG_fail;
25201 }
25202 resultobj = SWIG_Py_Void();
25203 {
25204 if (temp2)
25205 delete arg2;
25206 }
25207 return resultobj;
25208 fail:
25209 {
25210 if (temp2)
25211 delete arg2;
25212 }
25213 return NULL;
25214 }
25215
25216
25217 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25218 PyObject *resultobj = 0;
25219 long arg1 ;
25220 long val1 ;
25221 int ecode1 = 0 ;
25222 PyObject * obj0 = 0 ;
25223 char * kwnames[] = {
25224 (char *) "updateInterval", NULL
25225 };
25226
25227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25228 ecode1 = SWIG_AsVal_long(obj0, &val1);
25229 if (!SWIG_IsOK(ecode1)) {
25230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25231 }
25232 arg1 = static_cast< long >(val1);
25233 {
25234 PyThreadState* __tstate = wxPyBeginAllowThreads();
25235 wxUpdateUIEvent::SetUpdateInterval(arg1);
25236 wxPyEndAllowThreads(__tstate);
25237 if (PyErr_Occurred()) SWIG_fail;
25238 }
25239 resultobj = SWIG_Py_Void();
25240 return resultobj;
25241 fail:
25242 return NULL;
25243 }
25244
25245
25246 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25247 PyObject *resultobj = 0;
25248 long result;
25249
25250 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25251 {
25252 PyThreadState* __tstate = wxPyBeginAllowThreads();
25253 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25254 wxPyEndAllowThreads(__tstate);
25255 if (PyErr_Occurred()) SWIG_fail;
25256 }
25257 resultobj = SWIG_From_long(static_cast< long >(result));
25258 return resultobj;
25259 fail:
25260 return NULL;
25261 }
25262
25263
25264 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25265 PyObject *resultobj = 0;
25266 wxWindow *arg1 = (wxWindow *) 0 ;
25267 bool result;
25268 void *argp1 = 0 ;
25269 int res1 = 0 ;
25270 PyObject * obj0 = 0 ;
25271 char * kwnames[] = {
25272 (char *) "win", NULL
25273 };
25274
25275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25277 if (!SWIG_IsOK(res1)) {
25278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25279 }
25280 arg1 = reinterpret_cast< wxWindow * >(argp1);
25281 {
25282 PyThreadState* __tstate = wxPyBeginAllowThreads();
25283 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25284 wxPyEndAllowThreads(__tstate);
25285 if (PyErr_Occurred()) SWIG_fail;
25286 }
25287 {
25288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25289 }
25290 return resultobj;
25291 fail:
25292 return NULL;
25293 }
25294
25295
25296 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25297 PyObject *resultobj = 0;
25298
25299 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25300 {
25301 PyThreadState* __tstate = wxPyBeginAllowThreads();
25302 wxUpdateUIEvent::ResetUpdateTime();
25303 wxPyEndAllowThreads(__tstate);
25304 if (PyErr_Occurred()) SWIG_fail;
25305 }
25306 resultobj = SWIG_Py_Void();
25307 return resultobj;
25308 fail:
25309 return NULL;
25310 }
25311
25312
25313 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25314 PyObject *resultobj = 0;
25315 wxUpdateUIMode arg1 ;
25316 int val1 ;
25317 int ecode1 = 0 ;
25318 PyObject * obj0 = 0 ;
25319 char * kwnames[] = {
25320 (char *) "mode", NULL
25321 };
25322
25323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25324 ecode1 = SWIG_AsVal_int(obj0, &val1);
25325 if (!SWIG_IsOK(ecode1)) {
25326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25327 }
25328 arg1 = static_cast< wxUpdateUIMode >(val1);
25329 {
25330 PyThreadState* __tstate = wxPyBeginAllowThreads();
25331 wxUpdateUIEvent::SetMode(arg1);
25332 wxPyEndAllowThreads(__tstate);
25333 if (PyErr_Occurred()) SWIG_fail;
25334 }
25335 resultobj = SWIG_Py_Void();
25336 return resultobj;
25337 fail:
25338 return NULL;
25339 }
25340
25341
25342 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25343 PyObject *resultobj = 0;
25344 wxUpdateUIMode result;
25345
25346 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25347 {
25348 PyThreadState* __tstate = wxPyBeginAllowThreads();
25349 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25350 wxPyEndAllowThreads(__tstate);
25351 if (PyErr_Occurred()) SWIG_fail;
25352 }
25353 resultobj = SWIG_From_int(static_cast< int >(result));
25354 return resultobj;
25355 fail:
25356 return NULL;
25357 }
25358
25359
25360 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25361 PyObject *obj;
25362 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25363 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25364 return SWIG_Py_Void();
25365 }
25366
25367 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25368 return SWIG_Python_InitShadowInstance(args);
25369 }
25370
25371 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25372 PyObject *resultobj = 0;
25373 wxSysColourChangedEvent *result = 0 ;
25374
25375 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25376 {
25377 PyThreadState* __tstate = wxPyBeginAllowThreads();
25378 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25379 wxPyEndAllowThreads(__tstate);
25380 if (PyErr_Occurred()) SWIG_fail;
25381 }
25382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25383 return resultobj;
25384 fail:
25385 return NULL;
25386 }
25387
25388
25389 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25390 PyObject *obj;
25391 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25392 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25393 return SWIG_Py_Void();
25394 }
25395
25396 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25397 return SWIG_Python_InitShadowInstance(args);
25398 }
25399
25400 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25401 PyObject *resultobj = 0;
25402 int arg1 = (int) 0 ;
25403 wxWindow *arg2 = (wxWindow *) NULL ;
25404 wxMouseCaptureChangedEvent *result = 0 ;
25405 int val1 ;
25406 int ecode1 = 0 ;
25407 void *argp2 = 0 ;
25408 int res2 = 0 ;
25409 PyObject * obj0 = 0 ;
25410 PyObject * obj1 = 0 ;
25411 char * kwnames[] = {
25412 (char *) "winid",(char *) "gainedCapture", NULL
25413 };
25414
25415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25416 if (obj0) {
25417 ecode1 = SWIG_AsVal_int(obj0, &val1);
25418 if (!SWIG_IsOK(ecode1)) {
25419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25420 }
25421 arg1 = static_cast< int >(val1);
25422 }
25423 if (obj1) {
25424 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25425 if (!SWIG_IsOK(res2)) {
25426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25427 }
25428 arg2 = reinterpret_cast< wxWindow * >(argp2);
25429 }
25430 {
25431 PyThreadState* __tstate = wxPyBeginAllowThreads();
25432 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25433 wxPyEndAllowThreads(__tstate);
25434 if (PyErr_Occurred()) SWIG_fail;
25435 }
25436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25437 return resultobj;
25438 fail:
25439 return NULL;
25440 }
25441
25442
25443 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25444 PyObject *resultobj = 0;
25445 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25446 wxWindow *result = 0 ;
25447 void *argp1 = 0 ;
25448 int res1 = 0 ;
25449 PyObject *swig_obj[1] ;
25450
25451 if (!args) SWIG_fail;
25452 swig_obj[0] = args;
25453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25454 if (!SWIG_IsOK(res1)) {
25455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25456 }
25457 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25458 {
25459 PyThreadState* __tstate = wxPyBeginAllowThreads();
25460 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25461 wxPyEndAllowThreads(__tstate);
25462 if (PyErr_Occurred()) SWIG_fail;
25463 }
25464 {
25465 resultobj = wxPyMake_wxObject(result, (bool)0);
25466 }
25467 return resultobj;
25468 fail:
25469 return NULL;
25470 }
25471
25472
25473 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25474 PyObject *obj;
25475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25476 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25477 return SWIG_Py_Void();
25478 }
25479
25480 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25481 return SWIG_Python_InitShadowInstance(args);
25482 }
25483
25484 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25485 PyObject *resultobj = 0;
25486 wxDisplayChangedEvent *result = 0 ;
25487
25488 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25489 {
25490 PyThreadState* __tstate = wxPyBeginAllowThreads();
25491 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25492 wxPyEndAllowThreads(__tstate);
25493 if (PyErr_Occurred()) SWIG_fail;
25494 }
25495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25496 return resultobj;
25497 fail:
25498 return NULL;
25499 }
25500
25501
25502 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25503 PyObject *obj;
25504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25505 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25506 return SWIG_Py_Void();
25507 }
25508
25509 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25510 return SWIG_Python_InitShadowInstance(args);
25511 }
25512
25513 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25514 PyObject *resultobj = 0;
25515 int arg1 = (int) 0 ;
25516 wxPaletteChangedEvent *result = 0 ;
25517 int val1 ;
25518 int ecode1 = 0 ;
25519 PyObject * obj0 = 0 ;
25520 char * kwnames[] = {
25521 (char *) "id", NULL
25522 };
25523
25524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25525 if (obj0) {
25526 ecode1 = SWIG_AsVal_int(obj0, &val1);
25527 if (!SWIG_IsOK(ecode1)) {
25528 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25529 }
25530 arg1 = static_cast< int >(val1);
25531 }
25532 {
25533 PyThreadState* __tstate = wxPyBeginAllowThreads();
25534 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25535 wxPyEndAllowThreads(__tstate);
25536 if (PyErr_Occurred()) SWIG_fail;
25537 }
25538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25539 return resultobj;
25540 fail:
25541 return NULL;
25542 }
25543
25544
25545 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25546 PyObject *resultobj = 0;
25547 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25548 wxWindow *arg2 = (wxWindow *) 0 ;
25549 void *argp1 = 0 ;
25550 int res1 = 0 ;
25551 void *argp2 = 0 ;
25552 int res2 = 0 ;
25553 PyObject * obj0 = 0 ;
25554 PyObject * obj1 = 0 ;
25555 char * kwnames[] = {
25556 (char *) "self",(char *) "win", NULL
25557 };
25558
25559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25561 if (!SWIG_IsOK(res1)) {
25562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25563 }
25564 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25565 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25566 if (!SWIG_IsOK(res2)) {
25567 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25568 }
25569 arg2 = reinterpret_cast< wxWindow * >(argp2);
25570 {
25571 PyThreadState* __tstate = wxPyBeginAllowThreads();
25572 (arg1)->SetChangedWindow(arg2);
25573 wxPyEndAllowThreads(__tstate);
25574 if (PyErr_Occurred()) SWIG_fail;
25575 }
25576 resultobj = SWIG_Py_Void();
25577 return resultobj;
25578 fail:
25579 return NULL;
25580 }
25581
25582
25583 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25584 PyObject *resultobj = 0;
25585 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25586 wxWindow *result = 0 ;
25587 void *argp1 = 0 ;
25588 int res1 = 0 ;
25589 PyObject *swig_obj[1] ;
25590
25591 if (!args) SWIG_fail;
25592 swig_obj[0] = args;
25593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25594 if (!SWIG_IsOK(res1)) {
25595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25596 }
25597 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25598 {
25599 PyThreadState* __tstate = wxPyBeginAllowThreads();
25600 result = (wxWindow *)(arg1)->GetChangedWindow();
25601 wxPyEndAllowThreads(__tstate);
25602 if (PyErr_Occurred()) SWIG_fail;
25603 }
25604 {
25605 resultobj = wxPyMake_wxObject(result, (bool)0);
25606 }
25607 return resultobj;
25608 fail:
25609 return NULL;
25610 }
25611
25612
25613 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25614 PyObject *obj;
25615 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25616 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25617 return SWIG_Py_Void();
25618 }
25619
25620 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25621 return SWIG_Python_InitShadowInstance(args);
25622 }
25623
25624 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25625 PyObject *resultobj = 0;
25626 int arg1 = (int) 0 ;
25627 wxQueryNewPaletteEvent *result = 0 ;
25628 int val1 ;
25629 int ecode1 = 0 ;
25630 PyObject * obj0 = 0 ;
25631 char * kwnames[] = {
25632 (char *) "winid", NULL
25633 };
25634
25635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25636 if (obj0) {
25637 ecode1 = SWIG_AsVal_int(obj0, &val1);
25638 if (!SWIG_IsOK(ecode1)) {
25639 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25640 }
25641 arg1 = static_cast< int >(val1);
25642 }
25643 {
25644 PyThreadState* __tstate = wxPyBeginAllowThreads();
25645 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25646 wxPyEndAllowThreads(__tstate);
25647 if (PyErr_Occurred()) SWIG_fail;
25648 }
25649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25650 return resultobj;
25651 fail:
25652 return NULL;
25653 }
25654
25655
25656 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25657 PyObject *resultobj = 0;
25658 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25659 bool arg2 ;
25660 void *argp1 = 0 ;
25661 int res1 = 0 ;
25662 bool val2 ;
25663 int ecode2 = 0 ;
25664 PyObject * obj0 = 0 ;
25665 PyObject * obj1 = 0 ;
25666 char * kwnames[] = {
25667 (char *) "self",(char *) "realized", NULL
25668 };
25669
25670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25672 if (!SWIG_IsOK(res1)) {
25673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25674 }
25675 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25676 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25677 if (!SWIG_IsOK(ecode2)) {
25678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25679 }
25680 arg2 = static_cast< bool >(val2);
25681 {
25682 PyThreadState* __tstate = wxPyBeginAllowThreads();
25683 (arg1)->SetPaletteRealized(arg2);
25684 wxPyEndAllowThreads(__tstate);
25685 if (PyErr_Occurred()) SWIG_fail;
25686 }
25687 resultobj = SWIG_Py_Void();
25688 return resultobj;
25689 fail:
25690 return NULL;
25691 }
25692
25693
25694 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25695 PyObject *resultobj = 0;
25696 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25697 bool result;
25698 void *argp1 = 0 ;
25699 int res1 = 0 ;
25700 PyObject *swig_obj[1] ;
25701
25702 if (!args) SWIG_fail;
25703 swig_obj[0] = args;
25704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25705 if (!SWIG_IsOK(res1)) {
25706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25707 }
25708 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25709 {
25710 PyThreadState* __tstate = wxPyBeginAllowThreads();
25711 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25712 wxPyEndAllowThreads(__tstate);
25713 if (PyErr_Occurred()) SWIG_fail;
25714 }
25715 {
25716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25717 }
25718 return resultobj;
25719 fail:
25720 return NULL;
25721 }
25722
25723
25724 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25725 PyObject *obj;
25726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25727 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25728 return SWIG_Py_Void();
25729 }
25730
25731 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25732 return SWIG_Python_InitShadowInstance(args);
25733 }
25734
25735 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25736 PyObject *resultobj = 0;
25737 wxNavigationKeyEvent *result = 0 ;
25738
25739 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25740 {
25741 PyThreadState* __tstate = wxPyBeginAllowThreads();
25742 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25743 wxPyEndAllowThreads(__tstate);
25744 if (PyErr_Occurred()) SWIG_fail;
25745 }
25746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25747 return resultobj;
25748 fail:
25749 return NULL;
25750 }
25751
25752
25753 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25754 PyObject *resultobj = 0;
25755 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25756 bool result;
25757 void *argp1 = 0 ;
25758 int res1 = 0 ;
25759 PyObject *swig_obj[1] ;
25760
25761 if (!args) SWIG_fail;
25762 swig_obj[0] = args;
25763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25764 if (!SWIG_IsOK(res1)) {
25765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25766 }
25767 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25768 {
25769 PyThreadState* __tstate = wxPyBeginAllowThreads();
25770 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25771 wxPyEndAllowThreads(__tstate);
25772 if (PyErr_Occurred()) SWIG_fail;
25773 }
25774 {
25775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25776 }
25777 return resultobj;
25778 fail:
25779 return NULL;
25780 }
25781
25782
25783 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25784 PyObject *resultobj = 0;
25785 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25786 bool arg2 ;
25787 void *argp1 = 0 ;
25788 int res1 = 0 ;
25789 bool val2 ;
25790 int ecode2 = 0 ;
25791 PyObject * obj0 = 0 ;
25792 PyObject * obj1 = 0 ;
25793 char * kwnames[] = {
25794 (char *) "self",(char *) "forward", NULL
25795 };
25796
25797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25799 if (!SWIG_IsOK(res1)) {
25800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25801 }
25802 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25803 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25804 if (!SWIG_IsOK(ecode2)) {
25805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25806 }
25807 arg2 = static_cast< bool >(val2);
25808 {
25809 PyThreadState* __tstate = wxPyBeginAllowThreads();
25810 (arg1)->SetDirection(arg2);
25811 wxPyEndAllowThreads(__tstate);
25812 if (PyErr_Occurred()) SWIG_fail;
25813 }
25814 resultobj = SWIG_Py_Void();
25815 return resultobj;
25816 fail:
25817 return NULL;
25818 }
25819
25820
25821 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25822 PyObject *resultobj = 0;
25823 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25824 bool result;
25825 void *argp1 = 0 ;
25826 int res1 = 0 ;
25827 PyObject *swig_obj[1] ;
25828
25829 if (!args) SWIG_fail;
25830 swig_obj[0] = args;
25831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25832 if (!SWIG_IsOK(res1)) {
25833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25834 }
25835 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25836 {
25837 PyThreadState* __tstate = wxPyBeginAllowThreads();
25838 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25839 wxPyEndAllowThreads(__tstate);
25840 if (PyErr_Occurred()) SWIG_fail;
25841 }
25842 {
25843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25844 }
25845 return resultobj;
25846 fail:
25847 return NULL;
25848 }
25849
25850
25851 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25852 PyObject *resultobj = 0;
25853 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25854 bool arg2 ;
25855 void *argp1 = 0 ;
25856 int res1 = 0 ;
25857 bool val2 ;
25858 int ecode2 = 0 ;
25859 PyObject * obj0 = 0 ;
25860 PyObject * obj1 = 0 ;
25861 char * kwnames[] = {
25862 (char *) "self",(char *) "ischange", NULL
25863 };
25864
25865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25867 if (!SWIG_IsOK(res1)) {
25868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25869 }
25870 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25871 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25872 if (!SWIG_IsOK(ecode2)) {
25873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25874 }
25875 arg2 = static_cast< bool >(val2);
25876 {
25877 PyThreadState* __tstate = wxPyBeginAllowThreads();
25878 (arg1)->SetWindowChange(arg2);
25879 wxPyEndAllowThreads(__tstate);
25880 if (PyErr_Occurred()) SWIG_fail;
25881 }
25882 resultobj = SWIG_Py_Void();
25883 return resultobj;
25884 fail:
25885 return NULL;
25886 }
25887
25888
25889 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25890 PyObject *resultobj = 0;
25891 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25892 bool result;
25893 void *argp1 = 0 ;
25894 int res1 = 0 ;
25895 PyObject *swig_obj[1] ;
25896
25897 if (!args) SWIG_fail;
25898 swig_obj[0] = args;
25899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25900 if (!SWIG_IsOK(res1)) {
25901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25902 }
25903 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25904 {
25905 PyThreadState* __tstate = wxPyBeginAllowThreads();
25906 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25907 wxPyEndAllowThreads(__tstate);
25908 if (PyErr_Occurred()) SWIG_fail;
25909 }
25910 {
25911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25912 }
25913 return resultobj;
25914 fail:
25915 return NULL;
25916 }
25917
25918
25919 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25920 PyObject *resultobj = 0;
25921 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25922 bool arg2 ;
25923 void *argp1 = 0 ;
25924 int res1 = 0 ;
25925 bool val2 ;
25926 int ecode2 = 0 ;
25927 PyObject * obj0 = 0 ;
25928 PyObject * obj1 = 0 ;
25929 char * kwnames[] = {
25930 (char *) "self",(char *) "bIs", NULL
25931 };
25932
25933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25935 if (!SWIG_IsOK(res1)) {
25936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25937 }
25938 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25939 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25940 if (!SWIG_IsOK(ecode2)) {
25941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25942 }
25943 arg2 = static_cast< bool >(val2);
25944 {
25945 PyThreadState* __tstate = wxPyBeginAllowThreads();
25946 (arg1)->SetFromTab(arg2);
25947 wxPyEndAllowThreads(__tstate);
25948 if (PyErr_Occurred()) SWIG_fail;
25949 }
25950 resultobj = SWIG_Py_Void();
25951 return resultobj;
25952 fail:
25953 return NULL;
25954 }
25955
25956
25957 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25958 PyObject *resultobj = 0;
25959 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25960 long arg2 ;
25961 void *argp1 = 0 ;
25962 int res1 = 0 ;
25963 long val2 ;
25964 int ecode2 = 0 ;
25965 PyObject * obj0 = 0 ;
25966 PyObject * obj1 = 0 ;
25967 char * kwnames[] = {
25968 (char *) "self",(char *) "flags", NULL
25969 };
25970
25971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25973 if (!SWIG_IsOK(res1)) {
25974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25975 }
25976 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25977 ecode2 = SWIG_AsVal_long(obj1, &val2);
25978 if (!SWIG_IsOK(ecode2)) {
25979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25980 }
25981 arg2 = static_cast< long >(val2);
25982 {
25983 PyThreadState* __tstate = wxPyBeginAllowThreads();
25984 (arg1)->SetFlags(arg2);
25985 wxPyEndAllowThreads(__tstate);
25986 if (PyErr_Occurred()) SWIG_fail;
25987 }
25988 resultobj = SWIG_Py_Void();
25989 return resultobj;
25990 fail:
25991 return NULL;
25992 }
25993
25994
25995 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25996 PyObject *resultobj = 0;
25997 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25998 wxWindow *result = 0 ;
25999 void *argp1 = 0 ;
26000 int res1 = 0 ;
26001 PyObject *swig_obj[1] ;
26002
26003 if (!args) SWIG_fail;
26004 swig_obj[0] = args;
26005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26006 if (!SWIG_IsOK(res1)) {
26007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26008 }
26009 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26010 {
26011 PyThreadState* __tstate = wxPyBeginAllowThreads();
26012 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26013 wxPyEndAllowThreads(__tstate);
26014 if (PyErr_Occurred()) SWIG_fail;
26015 }
26016 {
26017 resultobj = wxPyMake_wxObject(result, (bool)0);
26018 }
26019 return resultobj;
26020 fail:
26021 return NULL;
26022 }
26023
26024
26025 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26026 PyObject *resultobj = 0;
26027 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26028 wxWindow *arg2 = (wxWindow *) 0 ;
26029 void *argp1 = 0 ;
26030 int res1 = 0 ;
26031 void *argp2 = 0 ;
26032 int res2 = 0 ;
26033 PyObject * obj0 = 0 ;
26034 PyObject * obj1 = 0 ;
26035 char * kwnames[] = {
26036 (char *) "self",(char *) "win", NULL
26037 };
26038
26039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26041 if (!SWIG_IsOK(res1)) {
26042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26043 }
26044 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26045 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26046 if (!SWIG_IsOK(res2)) {
26047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26048 }
26049 arg2 = reinterpret_cast< wxWindow * >(argp2);
26050 {
26051 PyThreadState* __tstate = wxPyBeginAllowThreads();
26052 (arg1)->SetCurrentFocus(arg2);
26053 wxPyEndAllowThreads(__tstate);
26054 if (PyErr_Occurred()) SWIG_fail;
26055 }
26056 resultobj = SWIG_Py_Void();
26057 return resultobj;
26058 fail:
26059 return NULL;
26060 }
26061
26062
26063 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26064 PyObject *obj;
26065 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26066 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26067 return SWIG_Py_Void();
26068 }
26069
26070 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26071 return SWIG_Python_InitShadowInstance(args);
26072 }
26073
26074 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26075 PyObject *resultobj = 0;
26076 wxWindow *arg1 = (wxWindow *) NULL ;
26077 wxWindowCreateEvent *result = 0 ;
26078 void *argp1 = 0 ;
26079 int res1 = 0 ;
26080 PyObject * obj0 = 0 ;
26081 char * kwnames[] = {
26082 (char *) "win", NULL
26083 };
26084
26085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26086 if (obj0) {
26087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26088 if (!SWIG_IsOK(res1)) {
26089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26090 }
26091 arg1 = reinterpret_cast< wxWindow * >(argp1);
26092 }
26093 {
26094 PyThreadState* __tstate = wxPyBeginAllowThreads();
26095 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26096 wxPyEndAllowThreads(__tstate);
26097 if (PyErr_Occurred()) SWIG_fail;
26098 }
26099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26100 return resultobj;
26101 fail:
26102 return NULL;
26103 }
26104
26105
26106 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26107 PyObject *resultobj = 0;
26108 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26109 wxWindow *result = 0 ;
26110 void *argp1 = 0 ;
26111 int res1 = 0 ;
26112 PyObject *swig_obj[1] ;
26113
26114 if (!args) SWIG_fail;
26115 swig_obj[0] = args;
26116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26117 if (!SWIG_IsOK(res1)) {
26118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26119 }
26120 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26121 {
26122 PyThreadState* __tstate = wxPyBeginAllowThreads();
26123 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26124 wxPyEndAllowThreads(__tstate);
26125 if (PyErr_Occurred()) SWIG_fail;
26126 }
26127 {
26128 resultobj = wxPyMake_wxObject(result, (bool)0);
26129 }
26130 return resultobj;
26131 fail:
26132 return NULL;
26133 }
26134
26135
26136 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26137 PyObject *obj;
26138 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26139 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26140 return SWIG_Py_Void();
26141 }
26142
26143 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26144 return SWIG_Python_InitShadowInstance(args);
26145 }
26146
26147 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26148 PyObject *resultobj = 0;
26149 wxWindow *arg1 = (wxWindow *) NULL ;
26150 wxWindowDestroyEvent *result = 0 ;
26151 void *argp1 = 0 ;
26152 int res1 = 0 ;
26153 PyObject * obj0 = 0 ;
26154 char * kwnames[] = {
26155 (char *) "win", NULL
26156 };
26157
26158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26159 if (obj0) {
26160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26161 if (!SWIG_IsOK(res1)) {
26162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26163 }
26164 arg1 = reinterpret_cast< wxWindow * >(argp1);
26165 }
26166 {
26167 PyThreadState* __tstate = wxPyBeginAllowThreads();
26168 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26169 wxPyEndAllowThreads(__tstate);
26170 if (PyErr_Occurred()) SWIG_fail;
26171 }
26172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26173 return resultobj;
26174 fail:
26175 return NULL;
26176 }
26177
26178
26179 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26180 PyObject *resultobj = 0;
26181 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26182 wxWindow *result = 0 ;
26183 void *argp1 = 0 ;
26184 int res1 = 0 ;
26185 PyObject *swig_obj[1] ;
26186
26187 if (!args) SWIG_fail;
26188 swig_obj[0] = args;
26189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26190 if (!SWIG_IsOK(res1)) {
26191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26192 }
26193 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26194 {
26195 PyThreadState* __tstate = wxPyBeginAllowThreads();
26196 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26197 wxPyEndAllowThreads(__tstate);
26198 if (PyErr_Occurred()) SWIG_fail;
26199 }
26200 {
26201 resultobj = wxPyMake_wxObject(result, (bool)0);
26202 }
26203 return resultobj;
26204 fail:
26205 return NULL;
26206 }
26207
26208
26209 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26210 PyObject *obj;
26211 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26212 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26213 return SWIG_Py_Void();
26214 }
26215
26216 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26217 return SWIG_Python_InitShadowInstance(args);
26218 }
26219
26220 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26221 PyObject *resultobj = 0;
26222 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26223 int arg2 = (int) 0 ;
26224 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26225 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26226 wxContextMenuEvent *result = 0 ;
26227 int val1 ;
26228 int ecode1 = 0 ;
26229 int val2 ;
26230 int ecode2 = 0 ;
26231 wxPoint temp3 ;
26232 PyObject * obj0 = 0 ;
26233 PyObject * obj1 = 0 ;
26234 PyObject * obj2 = 0 ;
26235 char * kwnames[] = {
26236 (char *) "type",(char *) "winid",(char *) "pt", NULL
26237 };
26238
26239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26240 if (obj0) {
26241 ecode1 = SWIG_AsVal_int(obj0, &val1);
26242 if (!SWIG_IsOK(ecode1)) {
26243 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26244 }
26245 arg1 = static_cast< wxEventType >(val1);
26246 }
26247 if (obj1) {
26248 ecode2 = SWIG_AsVal_int(obj1, &val2);
26249 if (!SWIG_IsOK(ecode2)) {
26250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26251 }
26252 arg2 = static_cast< int >(val2);
26253 }
26254 if (obj2) {
26255 {
26256 arg3 = &temp3;
26257 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26258 }
26259 }
26260 {
26261 PyThreadState* __tstate = wxPyBeginAllowThreads();
26262 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26263 wxPyEndAllowThreads(__tstate);
26264 if (PyErr_Occurred()) SWIG_fail;
26265 }
26266 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26267 return resultobj;
26268 fail:
26269 return NULL;
26270 }
26271
26272
26273 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26274 PyObject *resultobj = 0;
26275 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26276 wxPoint *result = 0 ;
26277 void *argp1 = 0 ;
26278 int res1 = 0 ;
26279 PyObject *swig_obj[1] ;
26280
26281 if (!args) SWIG_fail;
26282 swig_obj[0] = args;
26283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26284 if (!SWIG_IsOK(res1)) {
26285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26286 }
26287 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26288 {
26289 PyThreadState* __tstate = wxPyBeginAllowThreads();
26290 {
26291 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26292 result = (wxPoint *) &_result_ref;
26293 }
26294 wxPyEndAllowThreads(__tstate);
26295 if (PyErr_Occurred()) SWIG_fail;
26296 }
26297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26298 return resultobj;
26299 fail:
26300 return NULL;
26301 }
26302
26303
26304 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26305 PyObject *resultobj = 0;
26306 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26307 wxPoint *arg2 = 0 ;
26308 void *argp1 = 0 ;
26309 int res1 = 0 ;
26310 wxPoint temp2 ;
26311 PyObject * obj0 = 0 ;
26312 PyObject * obj1 = 0 ;
26313 char * kwnames[] = {
26314 (char *) "self",(char *) "pos", NULL
26315 };
26316
26317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26319 if (!SWIG_IsOK(res1)) {
26320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26321 }
26322 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26323 {
26324 arg2 = &temp2;
26325 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26326 }
26327 {
26328 PyThreadState* __tstate = wxPyBeginAllowThreads();
26329 (arg1)->SetPosition((wxPoint const &)*arg2);
26330 wxPyEndAllowThreads(__tstate);
26331 if (PyErr_Occurred()) SWIG_fail;
26332 }
26333 resultobj = SWIG_Py_Void();
26334 return resultobj;
26335 fail:
26336 return NULL;
26337 }
26338
26339
26340 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26341 PyObject *obj;
26342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26343 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26344 return SWIG_Py_Void();
26345 }
26346
26347 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26348 return SWIG_Python_InitShadowInstance(args);
26349 }
26350
26351 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26352 PyObject *resultobj = 0;
26353 wxIdleEvent *result = 0 ;
26354
26355 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26356 {
26357 PyThreadState* __tstate = wxPyBeginAllowThreads();
26358 result = (wxIdleEvent *)new wxIdleEvent();
26359 wxPyEndAllowThreads(__tstate);
26360 if (PyErr_Occurred()) SWIG_fail;
26361 }
26362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26363 return resultobj;
26364 fail:
26365 return NULL;
26366 }
26367
26368
26369 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26370 PyObject *resultobj = 0;
26371 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26372 bool arg2 = (bool) true ;
26373 void *argp1 = 0 ;
26374 int res1 = 0 ;
26375 bool val2 ;
26376 int ecode2 = 0 ;
26377 PyObject * obj0 = 0 ;
26378 PyObject * obj1 = 0 ;
26379 char * kwnames[] = {
26380 (char *) "self",(char *) "needMore", NULL
26381 };
26382
26383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26385 if (!SWIG_IsOK(res1)) {
26386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26387 }
26388 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26389 if (obj1) {
26390 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26391 if (!SWIG_IsOK(ecode2)) {
26392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26393 }
26394 arg2 = static_cast< bool >(val2);
26395 }
26396 {
26397 PyThreadState* __tstate = wxPyBeginAllowThreads();
26398 (arg1)->RequestMore(arg2);
26399 wxPyEndAllowThreads(__tstate);
26400 if (PyErr_Occurred()) SWIG_fail;
26401 }
26402 resultobj = SWIG_Py_Void();
26403 return resultobj;
26404 fail:
26405 return NULL;
26406 }
26407
26408
26409 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26410 PyObject *resultobj = 0;
26411 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26412 bool result;
26413 void *argp1 = 0 ;
26414 int res1 = 0 ;
26415 PyObject *swig_obj[1] ;
26416
26417 if (!args) SWIG_fail;
26418 swig_obj[0] = args;
26419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26420 if (!SWIG_IsOK(res1)) {
26421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26422 }
26423 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26424 {
26425 PyThreadState* __tstate = wxPyBeginAllowThreads();
26426 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26427 wxPyEndAllowThreads(__tstate);
26428 if (PyErr_Occurred()) SWIG_fail;
26429 }
26430 {
26431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26432 }
26433 return resultobj;
26434 fail:
26435 return NULL;
26436 }
26437
26438
26439 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26440 PyObject *resultobj = 0;
26441 wxIdleMode arg1 ;
26442 int val1 ;
26443 int ecode1 = 0 ;
26444 PyObject * obj0 = 0 ;
26445 char * kwnames[] = {
26446 (char *) "mode", NULL
26447 };
26448
26449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26450 ecode1 = SWIG_AsVal_int(obj0, &val1);
26451 if (!SWIG_IsOK(ecode1)) {
26452 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26453 }
26454 arg1 = static_cast< wxIdleMode >(val1);
26455 {
26456 PyThreadState* __tstate = wxPyBeginAllowThreads();
26457 wxIdleEvent::SetMode(arg1);
26458 wxPyEndAllowThreads(__tstate);
26459 if (PyErr_Occurred()) SWIG_fail;
26460 }
26461 resultobj = SWIG_Py_Void();
26462 return resultobj;
26463 fail:
26464 return NULL;
26465 }
26466
26467
26468 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26469 PyObject *resultobj = 0;
26470 wxIdleMode result;
26471
26472 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26473 {
26474 PyThreadState* __tstate = wxPyBeginAllowThreads();
26475 result = (wxIdleMode)wxIdleEvent::GetMode();
26476 wxPyEndAllowThreads(__tstate);
26477 if (PyErr_Occurred()) SWIG_fail;
26478 }
26479 resultobj = SWIG_From_int(static_cast< int >(result));
26480 return resultobj;
26481 fail:
26482 return NULL;
26483 }
26484
26485
26486 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26487 PyObject *resultobj = 0;
26488 wxWindow *arg1 = (wxWindow *) 0 ;
26489 bool result;
26490 void *argp1 = 0 ;
26491 int res1 = 0 ;
26492 PyObject * obj0 = 0 ;
26493 char * kwnames[] = {
26494 (char *) "win", NULL
26495 };
26496
26497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26499 if (!SWIG_IsOK(res1)) {
26500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26501 }
26502 arg1 = reinterpret_cast< wxWindow * >(argp1);
26503 {
26504 PyThreadState* __tstate = wxPyBeginAllowThreads();
26505 result = (bool)wxIdleEvent::CanSend(arg1);
26506 wxPyEndAllowThreads(__tstate);
26507 if (PyErr_Occurred()) SWIG_fail;
26508 }
26509 {
26510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26511 }
26512 return resultobj;
26513 fail:
26514 return NULL;
26515 }
26516
26517
26518 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26519 PyObject *obj;
26520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26521 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26522 return SWIG_Py_Void();
26523 }
26524
26525 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26526 return SWIG_Python_InitShadowInstance(args);
26527 }
26528
26529 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26530 PyObject *resultobj = 0;
26531 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26532 int arg2 = (int) 0 ;
26533 wxClipboardTextEvent *result = 0 ;
26534 int val1 ;
26535 int ecode1 = 0 ;
26536 int val2 ;
26537 int ecode2 = 0 ;
26538 PyObject * obj0 = 0 ;
26539 PyObject * obj1 = 0 ;
26540 char * kwnames[] = {
26541 (char *) "type",(char *) "winid", NULL
26542 };
26543
26544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26545 if (obj0) {
26546 ecode1 = SWIG_AsVal_int(obj0, &val1);
26547 if (!SWIG_IsOK(ecode1)) {
26548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26549 }
26550 arg1 = static_cast< wxEventType >(val1);
26551 }
26552 if (obj1) {
26553 ecode2 = SWIG_AsVal_int(obj1, &val2);
26554 if (!SWIG_IsOK(ecode2)) {
26555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26556 }
26557 arg2 = static_cast< int >(val2);
26558 }
26559 {
26560 PyThreadState* __tstate = wxPyBeginAllowThreads();
26561 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26562 wxPyEndAllowThreads(__tstate);
26563 if (PyErr_Occurred()) SWIG_fail;
26564 }
26565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26566 return resultobj;
26567 fail:
26568 return NULL;
26569 }
26570
26571
26572 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26573 PyObject *obj;
26574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26575 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26576 return SWIG_Py_Void();
26577 }
26578
26579 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26580 return SWIG_Python_InitShadowInstance(args);
26581 }
26582
26583 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26584 PyObject *resultobj = 0;
26585 int arg1 = (int) 0 ;
26586 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26587 wxPyEvent *result = 0 ;
26588 int val1 ;
26589 int ecode1 = 0 ;
26590 int val2 ;
26591 int ecode2 = 0 ;
26592 PyObject * obj0 = 0 ;
26593 PyObject * obj1 = 0 ;
26594 char * kwnames[] = {
26595 (char *) "winid",(char *) "eventType", NULL
26596 };
26597
26598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26599 if (obj0) {
26600 ecode1 = SWIG_AsVal_int(obj0, &val1);
26601 if (!SWIG_IsOK(ecode1)) {
26602 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26603 }
26604 arg1 = static_cast< int >(val1);
26605 }
26606 if (obj1) {
26607 ecode2 = SWIG_AsVal_int(obj1, &val2);
26608 if (!SWIG_IsOK(ecode2)) {
26609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26610 }
26611 arg2 = static_cast< wxEventType >(val2);
26612 }
26613 {
26614 PyThreadState* __tstate = wxPyBeginAllowThreads();
26615 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26616 wxPyEndAllowThreads(__tstate);
26617 if (PyErr_Occurred()) SWIG_fail;
26618 }
26619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26620 return resultobj;
26621 fail:
26622 return NULL;
26623 }
26624
26625
26626 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26627 PyObject *resultobj = 0;
26628 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26629 void *argp1 = 0 ;
26630 int res1 = 0 ;
26631 PyObject *swig_obj[1] ;
26632
26633 if (!args) SWIG_fail;
26634 swig_obj[0] = args;
26635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26636 if (!SWIG_IsOK(res1)) {
26637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26638 }
26639 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26640 {
26641 PyThreadState* __tstate = wxPyBeginAllowThreads();
26642 delete arg1;
26643
26644 wxPyEndAllowThreads(__tstate);
26645 if (PyErr_Occurred()) SWIG_fail;
26646 }
26647 resultobj = SWIG_Py_Void();
26648 return resultobj;
26649 fail:
26650 return NULL;
26651 }
26652
26653
26654 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26655 PyObject *resultobj = 0;
26656 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26657 PyObject *arg2 = (PyObject *) 0 ;
26658 void *argp1 = 0 ;
26659 int res1 = 0 ;
26660 PyObject * obj0 = 0 ;
26661 PyObject * obj1 = 0 ;
26662 char * kwnames[] = {
26663 (char *) "self",(char *) "self", NULL
26664 };
26665
26666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26668 if (!SWIG_IsOK(res1)) {
26669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26670 }
26671 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26672 arg2 = obj1;
26673 {
26674 PyThreadState* __tstate = wxPyBeginAllowThreads();
26675 (arg1)->SetSelf(arg2);
26676 wxPyEndAllowThreads(__tstate);
26677 if (PyErr_Occurred()) SWIG_fail;
26678 }
26679 resultobj = SWIG_Py_Void();
26680 return resultobj;
26681 fail:
26682 return NULL;
26683 }
26684
26685
26686 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26687 PyObject *resultobj = 0;
26688 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26689 PyObject *result = 0 ;
26690 void *argp1 = 0 ;
26691 int res1 = 0 ;
26692 PyObject *swig_obj[1] ;
26693
26694 if (!args) SWIG_fail;
26695 swig_obj[0] = args;
26696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26697 if (!SWIG_IsOK(res1)) {
26698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26699 }
26700 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26701 {
26702 PyThreadState* __tstate = wxPyBeginAllowThreads();
26703 result = (PyObject *)(arg1)->GetSelf();
26704 wxPyEndAllowThreads(__tstate);
26705 if (PyErr_Occurred()) SWIG_fail;
26706 }
26707 resultobj = result;
26708 return resultobj;
26709 fail:
26710 return NULL;
26711 }
26712
26713
26714 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26715 PyObject *obj;
26716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26717 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26718 return SWIG_Py_Void();
26719 }
26720
26721 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26722 return SWIG_Python_InitShadowInstance(args);
26723 }
26724
26725 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26726 PyObject *resultobj = 0;
26727 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26728 int arg2 = (int) 0 ;
26729 wxPyCommandEvent *result = 0 ;
26730 int val1 ;
26731 int ecode1 = 0 ;
26732 int val2 ;
26733 int ecode2 = 0 ;
26734 PyObject * obj0 = 0 ;
26735 PyObject * obj1 = 0 ;
26736 char * kwnames[] = {
26737 (char *) "eventType",(char *) "id", NULL
26738 };
26739
26740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26741 if (obj0) {
26742 ecode1 = SWIG_AsVal_int(obj0, &val1);
26743 if (!SWIG_IsOK(ecode1)) {
26744 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26745 }
26746 arg1 = static_cast< wxEventType >(val1);
26747 }
26748 if (obj1) {
26749 ecode2 = SWIG_AsVal_int(obj1, &val2);
26750 if (!SWIG_IsOK(ecode2)) {
26751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26752 }
26753 arg2 = static_cast< int >(val2);
26754 }
26755 {
26756 PyThreadState* __tstate = wxPyBeginAllowThreads();
26757 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26758 wxPyEndAllowThreads(__tstate);
26759 if (PyErr_Occurred()) SWIG_fail;
26760 }
26761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26762 return resultobj;
26763 fail:
26764 return NULL;
26765 }
26766
26767
26768 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26769 PyObject *resultobj = 0;
26770 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26771 void *argp1 = 0 ;
26772 int res1 = 0 ;
26773 PyObject *swig_obj[1] ;
26774
26775 if (!args) SWIG_fail;
26776 swig_obj[0] = args;
26777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26778 if (!SWIG_IsOK(res1)) {
26779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26780 }
26781 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26782 {
26783 PyThreadState* __tstate = wxPyBeginAllowThreads();
26784 delete arg1;
26785
26786 wxPyEndAllowThreads(__tstate);
26787 if (PyErr_Occurred()) SWIG_fail;
26788 }
26789 resultobj = SWIG_Py_Void();
26790 return resultobj;
26791 fail:
26792 return NULL;
26793 }
26794
26795
26796 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26797 PyObject *resultobj = 0;
26798 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26799 PyObject *arg2 = (PyObject *) 0 ;
26800 void *argp1 = 0 ;
26801 int res1 = 0 ;
26802 PyObject * obj0 = 0 ;
26803 PyObject * obj1 = 0 ;
26804 char * kwnames[] = {
26805 (char *) "self",(char *) "self", NULL
26806 };
26807
26808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26810 if (!SWIG_IsOK(res1)) {
26811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26812 }
26813 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26814 arg2 = obj1;
26815 {
26816 PyThreadState* __tstate = wxPyBeginAllowThreads();
26817 (arg1)->SetSelf(arg2);
26818 wxPyEndAllowThreads(__tstate);
26819 if (PyErr_Occurred()) SWIG_fail;
26820 }
26821 resultobj = SWIG_Py_Void();
26822 return resultobj;
26823 fail:
26824 return NULL;
26825 }
26826
26827
26828 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26829 PyObject *resultobj = 0;
26830 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26831 PyObject *result = 0 ;
26832 void *argp1 = 0 ;
26833 int res1 = 0 ;
26834 PyObject *swig_obj[1] ;
26835
26836 if (!args) SWIG_fail;
26837 swig_obj[0] = args;
26838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26839 if (!SWIG_IsOK(res1)) {
26840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26841 }
26842 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26843 {
26844 PyThreadState* __tstate = wxPyBeginAllowThreads();
26845 result = (PyObject *)(arg1)->GetSelf();
26846 wxPyEndAllowThreads(__tstate);
26847 if (PyErr_Occurred()) SWIG_fail;
26848 }
26849 resultobj = result;
26850 return resultobj;
26851 fail:
26852 return NULL;
26853 }
26854
26855
26856 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26857 PyObject *obj;
26858 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26859 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26860 return SWIG_Py_Void();
26861 }
26862
26863 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26864 return SWIG_Python_InitShadowInstance(args);
26865 }
26866
26867 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26868 PyObject *resultobj = 0;
26869 wxWindow *arg1 = (wxWindow *) 0 ;
26870 wxDateTime *arg2 = 0 ;
26871 wxEventType arg3 ;
26872 wxDateEvent *result = 0 ;
26873 void *argp1 = 0 ;
26874 int res1 = 0 ;
26875 void *argp2 = 0 ;
26876 int res2 = 0 ;
26877 int val3 ;
26878 int ecode3 = 0 ;
26879 PyObject * obj0 = 0 ;
26880 PyObject * obj1 = 0 ;
26881 PyObject * obj2 = 0 ;
26882 char * kwnames[] = {
26883 (char *) "win",(char *) "dt",(char *) "type", NULL
26884 };
26885
26886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26888 if (!SWIG_IsOK(res1)) {
26889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26890 }
26891 arg1 = reinterpret_cast< wxWindow * >(argp1);
26892 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26893 if (!SWIG_IsOK(res2)) {
26894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26895 }
26896 if (!argp2) {
26897 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26898 }
26899 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26900 ecode3 = SWIG_AsVal_int(obj2, &val3);
26901 if (!SWIG_IsOK(ecode3)) {
26902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26903 }
26904 arg3 = static_cast< wxEventType >(val3);
26905 {
26906 PyThreadState* __tstate = wxPyBeginAllowThreads();
26907 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26908 wxPyEndAllowThreads(__tstate);
26909 if (PyErr_Occurred()) SWIG_fail;
26910 }
26911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26912 return resultobj;
26913 fail:
26914 return NULL;
26915 }
26916
26917
26918 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26919 PyObject *resultobj = 0;
26920 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26921 wxDateTime *result = 0 ;
26922 void *argp1 = 0 ;
26923 int res1 = 0 ;
26924 PyObject *swig_obj[1] ;
26925
26926 if (!args) SWIG_fail;
26927 swig_obj[0] = args;
26928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26929 if (!SWIG_IsOK(res1)) {
26930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26931 }
26932 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26933 {
26934 PyThreadState* __tstate = wxPyBeginAllowThreads();
26935 {
26936 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26937 result = (wxDateTime *) &_result_ref;
26938 }
26939 wxPyEndAllowThreads(__tstate);
26940 if (PyErr_Occurred()) SWIG_fail;
26941 }
26942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26943 return resultobj;
26944 fail:
26945 return NULL;
26946 }
26947
26948
26949 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26950 PyObject *resultobj = 0;
26951 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26952 wxDateTime *arg2 = 0 ;
26953 void *argp1 = 0 ;
26954 int res1 = 0 ;
26955 void *argp2 = 0 ;
26956 int res2 = 0 ;
26957 PyObject * obj0 = 0 ;
26958 PyObject * obj1 = 0 ;
26959 char * kwnames[] = {
26960 (char *) "self",(char *) "date", NULL
26961 };
26962
26963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26965 if (!SWIG_IsOK(res1)) {
26966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26967 }
26968 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26969 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26970 if (!SWIG_IsOK(res2)) {
26971 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26972 }
26973 if (!argp2) {
26974 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26975 }
26976 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26977 {
26978 PyThreadState* __tstate = wxPyBeginAllowThreads();
26979 (arg1)->SetDate((wxDateTime const &)*arg2);
26980 wxPyEndAllowThreads(__tstate);
26981 if (PyErr_Occurred()) SWIG_fail;
26982 }
26983 resultobj = SWIG_Py_Void();
26984 return resultobj;
26985 fail:
26986 return NULL;
26987 }
26988
26989
26990 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26991 PyObject *obj;
26992 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26993 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26994 return SWIG_Py_Void();
26995 }
26996
26997 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26998 return SWIG_Python_InitShadowInstance(args);
26999 }
27000
27001 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27002 PyObject *resultobj = 0;
27003 wxPyApp *result = 0 ;
27004
27005 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27006 {
27007 PyThreadState* __tstate = wxPyBeginAllowThreads();
27008 result = (wxPyApp *)new_wxPyApp();
27009 wxPyEndAllowThreads(__tstate);
27010 if (PyErr_Occurred()) SWIG_fail;
27011 }
27012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27020 PyObject *resultobj = 0;
27021 wxPyApp *arg1 = (wxPyApp *) 0 ;
27022 void *argp1 = 0 ;
27023 int res1 = 0 ;
27024 PyObject *swig_obj[1] ;
27025
27026 if (!args) SWIG_fail;
27027 swig_obj[0] = args;
27028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27029 if (!SWIG_IsOK(res1)) {
27030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27031 }
27032 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27033 {
27034 PyThreadState* __tstate = wxPyBeginAllowThreads();
27035 delete arg1;
27036
27037 wxPyEndAllowThreads(__tstate);
27038 if (PyErr_Occurred()) SWIG_fail;
27039 }
27040 resultobj = SWIG_Py_Void();
27041 return resultobj;
27042 fail:
27043 return NULL;
27044 }
27045
27046
27047 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27048 PyObject *resultobj = 0;
27049 wxPyApp *arg1 = (wxPyApp *) 0 ;
27050 PyObject *arg2 = (PyObject *) 0 ;
27051 PyObject *arg3 = (PyObject *) 0 ;
27052 bool arg4 ;
27053 void *argp1 = 0 ;
27054 int res1 = 0 ;
27055 bool val4 ;
27056 int ecode4 = 0 ;
27057 PyObject * obj0 = 0 ;
27058 PyObject * obj1 = 0 ;
27059 PyObject * obj2 = 0 ;
27060 PyObject * obj3 = 0 ;
27061 char * kwnames[] = {
27062 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27063 };
27064
27065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27067 if (!SWIG_IsOK(res1)) {
27068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27069 }
27070 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27071 arg2 = obj1;
27072 arg3 = obj2;
27073 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27074 if (!SWIG_IsOK(ecode4)) {
27075 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27076 }
27077 arg4 = static_cast< bool >(val4);
27078 {
27079 PyThreadState* __tstate = wxPyBeginAllowThreads();
27080 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
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_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27092 PyObject *resultobj = 0;
27093 wxPyApp *arg1 = (wxPyApp *) 0 ;
27094 wxString 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_wxPyApp, 0 | 0 );
27102 if (!SWIG_IsOK(res1)) {
27103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27104 }
27105 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27106 {
27107 PyThreadState* __tstate = wxPyBeginAllowThreads();
27108 result = ((wxPyApp const *)arg1)->GetAppName();
27109 wxPyEndAllowThreads(__tstate);
27110 if (PyErr_Occurred()) SWIG_fail;
27111 }
27112 {
27113 #if wxUSE_UNICODE
27114 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27115 #else
27116 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27117 #endif
27118 }
27119 return resultobj;
27120 fail:
27121 return NULL;
27122 }
27123
27124
27125 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27126 PyObject *resultobj = 0;
27127 wxPyApp *arg1 = (wxPyApp *) 0 ;
27128 wxString *arg2 = 0 ;
27129 void *argp1 = 0 ;
27130 int res1 = 0 ;
27131 bool temp2 = false ;
27132 PyObject * obj0 = 0 ;
27133 PyObject * obj1 = 0 ;
27134 char * kwnames[] = {
27135 (char *) "self",(char *) "name", NULL
27136 };
27137
27138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27140 if (!SWIG_IsOK(res1)) {
27141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27142 }
27143 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27144 {
27145 arg2 = wxString_in_helper(obj1);
27146 if (arg2 == NULL) SWIG_fail;
27147 temp2 = true;
27148 }
27149 {
27150 PyThreadState* __tstate = wxPyBeginAllowThreads();
27151 (arg1)->SetAppName((wxString const &)*arg2);
27152 wxPyEndAllowThreads(__tstate);
27153 if (PyErr_Occurred()) SWIG_fail;
27154 }
27155 resultobj = SWIG_Py_Void();
27156 {
27157 if (temp2)
27158 delete arg2;
27159 }
27160 return resultobj;
27161 fail:
27162 {
27163 if (temp2)
27164 delete arg2;
27165 }
27166 return NULL;
27167 }
27168
27169
27170 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27171 PyObject *resultobj = 0;
27172 wxPyApp *arg1 = (wxPyApp *) 0 ;
27173 wxString result;
27174 void *argp1 = 0 ;
27175 int res1 = 0 ;
27176 PyObject *swig_obj[1] ;
27177
27178 if (!args) SWIG_fail;
27179 swig_obj[0] = args;
27180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27181 if (!SWIG_IsOK(res1)) {
27182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27183 }
27184 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27185 {
27186 PyThreadState* __tstate = wxPyBeginAllowThreads();
27187 result = ((wxPyApp const *)arg1)->GetClassName();
27188 wxPyEndAllowThreads(__tstate);
27189 if (PyErr_Occurred()) SWIG_fail;
27190 }
27191 {
27192 #if wxUSE_UNICODE
27193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27194 #else
27195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27196 #endif
27197 }
27198 return resultobj;
27199 fail:
27200 return NULL;
27201 }
27202
27203
27204 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27205 PyObject *resultobj = 0;
27206 wxPyApp *arg1 = (wxPyApp *) 0 ;
27207 wxString *arg2 = 0 ;
27208 void *argp1 = 0 ;
27209 int res1 = 0 ;
27210 bool temp2 = false ;
27211 PyObject * obj0 = 0 ;
27212 PyObject * obj1 = 0 ;
27213 char * kwnames[] = {
27214 (char *) "self",(char *) "name", NULL
27215 };
27216
27217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27219 if (!SWIG_IsOK(res1)) {
27220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27221 }
27222 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27223 {
27224 arg2 = wxString_in_helper(obj1);
27225 if (arg2 == NULL) SWIG_fail;
27226 temp2 = true;
27227 }
27228 {
27229 PyThreadState* __tstate = wxPyBeginAllowThreads();
27230 (arg1)->SetClassName((wxString const &)*arg2);
27231 wxPyEndAllowThreads(__tstate);
27232 if (PyErr_Occurred()) SWIG_fail;
27233 }
27234 resultobj = SWIG_Py_Void();
27235 {
27236 if (temp2)
27237 delete arg2;
27238 }
27239 return resultobj;
27240 fail:
27241 {
27242 if (temp2)
27243 delete arg2;
27244 }
27245 return NULL;
27246 }
27247
27248
27249 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27250 PyObject *resultobj = 0;
27251 wxPyApp *arg1 = (wxPyApp *) 0 ;
27252 wxString *result = 0 ;
27253 void *argp1 = 0 ;
27254 int res1 = 0 ;
27255 PyObject *swig_obj[1] ;
27256
27257 if (!args) SWIG_fail;
27258 swig_obj[0] = args;
27259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27260 if (!SWIG_IsOK(res1)) {
27261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27262 }
27263 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27264 {
27265 PyThreadState* __tstate = wxPyBeginAllowThreads();
27266 {
27267 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27268 result = (wxString *) &_result_ref;
27269 }
27270 wxPyEndAllowThreads(__tstate);
27271 if (PyErr_Occurred()) SWIG_fail;
27272 }
27273 {
27274 #if wxUSE_UNICODE
27275 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27276 #else
27277 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27278 #endif
27279 }
27280 return resultobj;
27281 fail:
27282 return NULL;
27283 }
27284
27285
27286 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27287 PyObject *resultobj = 0;
27288 wxPyApp *arg1 = (wxPyApp *) 0 ;
27289 wxString *arg2 = 0 ;
27290 void *argp1 = 0 ;
27291 int res1 = 0 ;
27292 bool temp2 = false ;
27293 PyObject * obj0 = 0 ;
27294 PyObject * obj1 = 0 ;
27295 char * kwnames[] = {
27296 (char *) "self",(char *) "name", NULL
27297 };
27298
27299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27301 if (!SWIG_IsOK(res1)) {
27302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27303 }
27304 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27305 {
27306 arg2 = wxString_in_helper(obj1);
27307 if (arg2 == NULL) SWIG_fail;
27308 temp2 = true;
27309 }
27310 {
27311 PyThreadState* __tstate = wxPyBeginAllowThreads();
27312 (arg1)->SetVendorName((wxString const &)*arg2);
27313 wxPyEndAllowThreads(__tstate);
27314 if (PyErr_Occurred()) SWIG_fail;
27315 }
27316 resultobj = SWIG_Py_Void();
27317 {
27318 if (temp2)
27319 delete arg2;
27320 }
27321 return resultobj;
27322 fail:
27323 {
27324 if (temp2)
27325 delete arg2;
27326 }
27327 return NULL;
27328 }
27329
27330
27331 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27332 PyObject *resultobj = 0;
27333 wxPyApp *arg1 = (wxPyApp *) 0 ;
27334 wxAppTraits *result = 0 ;
27335 void *argp1 = 0 ;
27336 int res1 = 0 ;
27337 PyObject *swig_obj[1] ;
27338
27339 if (!args) SWIG_fail;
27340 swig_obj[0] = args;
27341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27342 if (!SWIG_IsOK(res1)) {
27343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27344 }
27345 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27346 {
27347 PyThreadState* __tstate = wxPyBeginAllowThreads();
27348 result = (wxAppTraits *)(arg1)->GetTraits();
27349 wxPyEndAllowThreads(__tstate);
27350 if (PyErr_Occurred()) SWIG_fail;
27351 }
27352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27353 return resultobj;
27354 fail:
27355 return NULL;
27356 }
27357
27358
27359 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27360 PyObject *resultobj = 0;
27361 wxPyApp *arg1 = (wxPyApp *) 0 ;
27362 void *argp1 = 0 ;
27363 int res1 = 0 ;
27364 PyObject *swig_obj[1] ;
27365
27366 if (!args) SWIG_fail;
27367 swig_obj[0] = args;
27368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27369 if (!SWIG_IsOK(res1)) {
27370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27371 }
27372 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27373 {
27374 PyThreadState* __tstate = wxPyBeginAllowThreads();
27375 (arg1)->ProcessPendingEvents();
27376 wxPyEndAllowThreads(__tstate);
27377 if (PyErr_Occurred()) SWIG_fail;
27378 }
27379 resultobj = SWIG_Py_Void();
27380 return resultobj;
27381 fail:
27382 return NULL;
27383 }
27384
27385
27386 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27387 PyObject *resultobj = 0;
27388 wxPyApp *arg1 = (wxPyApp *) 0 ;
27389 bool arg2 = (bool) false ;
27390 bool result;
27391 void *argp1 = 0 ;
27392 int res1 = 0 ;
27393 bool val2 ;
27394 int ecode2 = 0 ;
27395 PyObject * obj0 = 0 ;
27396 PyObject * obj1 = 0 ;
27397 char * kwnames[] = {
27398 (char *) "self",(char *) "onlyIfNeeded", NULL
27399 };
27400
27401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27403 if (!SWIG_IsOK(res1)) {
27404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27405 }
27406 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27407 if (obj1) {
27408 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27409 if (!SWIG_IsOK(ecode2)) {
27410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27411 }
27412 arg2 = static_cast< bool >(val2);
27413 }
27414 {
27415 PyThreadState* __tstate = wxPyBeginAllowThreads();
27416 result = (bool)(arg1)->Yield(arg2);
27417 wxPyEndAllowThreads(__tstate);
27418 if (PyErr_Occurred()) SWIG_fail;
27419 }
27420 {
27421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27422 }
27423 return resultobj;
27424 fail:
27425 return NULL;
27426 }
27427
27428
27429 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27430 PyObject *resultobj = 0;
27431 wxPyApp *arg1 = (wxPyApp *) 0 ;
27432 void *argp1 = 0 ;
27433 int res1 = 0 ;
27434 PyObject *swig_obj[1] ;
27435
27436 if (!args) SWIG_fail;
27437 swig_obj[0] = args;
27438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27439 if (!SWIG_IsOK(res1)) {
27440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27441 }
27442 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27443 {
27444 PyThreadState* __tstate = wxPyBeginAllowThreads();
27445 (arg1)->WakeUpIdle();
27446 wxPyEndAllowThreads(__tstate);
27447 if (PyErr_Occurred()) SWIG_fail;
27448 }
27449 resultobj = SWIG_Py_Void();
27450 return resultobj;
27451 fail:
27452 return NULL;
27453 }
27454
27455
27456 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27457 PyObject *resultobj = 0;
27458 bool result;
27459
27460 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27461 {
27462 PyThreadState* __tstate = wxPyBeginAllowThreads();
27463 result = (bool)wxPyApp::IsMainLoopRunning();
27464 wxPyEndAllowThreads(__tstate);
27465 if (PyErr_Occurred()) SWIG_fail;
27466 }
27467 {
27468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27469 }
27470 return resultobj;
27471 fail:
27472 return NULL;
27473 }
27474
27475
27476 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27477 PyObject *resultobj = 0;
27478 wxPyApp *arg1 = (wxPyApp *) 0 ;
27479 int result;
27480 void *argp1 = 0 ;
27481 int res1 = 0 ;
27482 PyObject *swig_obj[1] ;
27483
27484 if (!args) SWIG_fail;
27485 swig_obj[0] = args;
27486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27487 if (!SWIG_IsOK(res1)) {
27488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27489 }
27490 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27491 {
27492 PyThreadState* __tstate = wxPyBeginAllowThreads();
27493 result = (int)(arg1)->MainLoop();
27494 wxPyEndAllowThreads(__tstate);
27495 if (PyErr_Occurred()) SWIG_fail;
27496 }
27497 resultobj = SWIG_From_int(static_cast< int >(result));
27498 return resultobj;
27499 fail:
27500 return NULL;
27501 }
27502
27503
27504 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27505 PyObject *resultobj = 0;
27506 wxPyApp *arg1 = (wxPyApp *) 0 ;
27507 void *argp1 = 0 ;
27508 int res1 = 0 ;
27509 PyObject *swig_obj[1] ;
27510
27511 if (!args) SWIG_fail;
27512 swig_obj[0] = args;
27513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27514 if (!SWIG_IsOK(res1)) {
27515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27516 }
27517 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27518 {
27519 PyThreadState* __tstate = wxPyBeginAllowThreads();
27520 (arg1)->Exit();
27521 wxPyEndAllowThreads(__tstate);
27522 if (PyErr_Occurred()) SWIG_fail;
27523 }
27524 resultobj = SWIG_Py_Void();
27525 return resultobj;
27526 fail:
27527 return NULL;
27528 }
27529
27530
27531 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27532 PyObject *resultobj = 0;
27533 wxPyApp *arg1 = (wxPyApp *) 0 ;
27534 void *argp1 = 0 ;
27535 int res1 = 0 ;
27536 PyObject *swig_obj[1] ;
27537
27538 if (!args) SWIG_fail;
27539 swig_obj[0] = args;
27540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27541 if (!SWIG_IsOK(res1)) {
27542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27543 }
27544 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27545 {
27546 PyThreadState* __tstate = wxPyBeginAllowThreads();
27547 (arg1)->ExitMainLoop();
27548 wxPyEndAllowThreads(__tstate);
27549 if (PyErr_Occurred()) SWIG_fail;
27550 }
27551 resultobj = SWIG_Py_Void();
27552 return resultobj;
27553 fail:
27554 return NULL;
27555 }
27556
27557
27558 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27559 PyObject *resultobj = 0;
27560 wxPyApp *arg1 = (wxPyApp *) 0 ;
27561 bool result;
27562 void *argp1 = 0 ;
27563 int res1 = 0 ;
27564 PyObject *swig_obj[1] ;
27565
27566 if (!args) SWIG_fail;
27567 swig_obj[0] = args;
27568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27569 if (!SWIG_IsOK(res1)) {
27570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27571 }
27572 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27573 {
27574 PyThreadState* __tstate = wxPyBeginAllowThreads();
27575 result = (bool)(arg1)->Pending();
27576 wxPyEndAllowThreads(__tstate);
27577 if (PyErr_Occurred()) SWIG_fail;
27578 }
27579 {
27580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27581 }
27582 return resultobj;
27583 fail:
27584 return NULL;
27585 }
27586
27587
27588 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27589 PyObject *resultobj = 0;
27590 wxPyApp *arg1 = (wxPyApp *) 0 ;
27591 bool result;
27592 void *argp1 = 0 ;
27593 int res1 = 0 ;
27594 PyObject *swig_obj[1] ;
27595
27596 if (!args) SWIG_fail;
27597 swig_obj[0] = args;
27598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27599 if (!SWIG_IsOK(res1)) {
27600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27601 }
27602 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27603 {
27604 PyThreadState* __tstate = wxPyBeginAllowThreads();
27605 result = (bool)(arg1)->Dispatch();
27606 wxPyEndAllowThreads(__tstate);
27607 if (PyErr_Occurred()) SWIG_fail;
27608 }
27609 {
27610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27611 }
27612 return resultobj;
27613 fail:
27614 return NULL;
27615 }
27616
27617
27618 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27619 PyObject *resultobj = 0;
27620 wxPyApp *arg1 = (wxPyApp *) 0 ;
27621 bool result;
27622 void *argp1 = 0 ;
27623 int res1 = 0 ;
27624 PyObject *swig_obj[1] ;
27625
27626 if (!args) SWIG_fail;
27627 swig_obj[0] = args;
27628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27629 if (!SWIG_IsOK(res1)) {
27630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27631 }
27632 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27633 {
27634 PyThreadState* __tstate = wxPyBeginAllowThreads();
27635 result = (bool)(arg1)->ProcessIdle();
27636 wxPyEndAllowThreads(__tstate);
27637 if (PyErr_Occurred()) SWIG_fail;
27638 }
27639 {
27640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27641 }
27642 return resultobj;
27643 fail:
27644 return NULL;
27645 }
27646
27647
27648 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27649 PyObject *resultobj = 0;
27650 wxPyApp *arg1 = (wxPyApp *) 0 ;
27651 wxWindow *arg2 = (wxWindow *) 0 ;
27652 wxIdleEvent *arg3 = 0 ;
27653 bool result;
27654 void *argp1 = 0 ;
27655 int res1 = 0 ;
27656 void *argp2 = 0 ;
27657 int res2 = 0 ;
27658 void *argp3 = 0 ;
27659 int res3 = 0 ;
27660 PyObject * obj0 = 0 ;
27661 PyObject * obj1 = 0 ;
27662 PyObject * obj2 = 0 ;
27663 char * kwnames[] = {
27664 (char *) "self",(char *) "win",(char *) "event", NULL
27665 };
27666
27667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27669 if (!SWIG_IsOK(res1)) {
27670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27671 }
27672 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27673 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27674 if (!SWIG_IsOK(res2)) {
27675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27676 }
27677 arg2 = reinterpret_cast< wxWindow * >(argp2);
27678 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27679 if (!SWIG_IsOK(res3)) {
27680 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27681 }
27682 if (!argp3) {
27683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27684 }
27685 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27686 {
27687 PyThreadState* __tstate = wxPyBeginAllowThreads();
27688 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27689 wxPyEndAllowThreads(__tstate);
27690 if (PyErr_Occurred()) SWIG_fail;
27691 }
27692 {
27693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27694 }
27695 return resultobj;
27696 fail:
27697 return NULL;
27698 }
27699
27700
27701 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27702 PyObject *resultobj = 0;
27703 wxPyApp *arg1 = (wxPyApp *) 0 ;
27704 bool result;
27705 void *argp1 = 0 ;
27706 int res1 = 0 ;
27707 PyObject *swig_obj[1] ;
27708
27709 if (!args) SWIG_fail;
27710 swig_obj[0] = args;
27711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27712 if (!SWIG_IsOK(res1)) {
27713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27714 }
27715 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27716 {
27717 PyThreadState* __tstate = wxPyBeginAllowThreads();
27718 result = (bool)((wxPyApp const *)arg1)->IsActive();
27719 wxPyEndAllowThreads(__tstate);
27720 if (PyErr_Occurred()) SWIG_fail;
27721 }
27722 {
27723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27724 }
27725 return resultobj;
27726 fail:
27727 return NULL;
27728 }
27729
27730
27731 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27732 PyObject *resultobj = 0;
27733 wxPyApp *arg1 = (wxPyApp *) 0 ;
27734 wxWindow *arg2 = (wxWindow *) 0 ;
27735 void *argp1 = 0 ;
27736 int res1 = 0 ;
27737 void *argp2 = 0 ;
27738 int res2 = 0 ;
27739 PyObject * obj0 = 0 ;
27740 PyObject * obj1 = 0 ;
27741 char * kwnames[] = {
27742 (char *) "self",(char *) "win", NULL
27743 };
27744
27745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27747 if (!SWIG_IsOK(res1)) {
27748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27749 }
27750 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27752 if (!SWIG_IsOK(res2)) {
27753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27754 }
27755 arg2 = reinterpret_cast< wxWindow * >(argp2);
27756 {
27757 PyThreadState* __tstate = wxPyBeginAllowThreads();
27758 (arg1)->SetTopWindow(arg2);
27759 wxPyEndAllowThreads(__tstate);
27760 if (PyErr_Occurred()) SWIG_fail;
27761 }
27762 resultobj = SWIG_Py_Void();
27763 return resultobj;
27764 fail:
27765 return NULL;
27766 }
27767
27768
27769 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27770 PyObject *resultobj = 0;
27771 wxPyApp *arg1 = (wxPyApp *) 0 ;
27772 wxWindow *result = 0 ;
27773 void *argp1 = 0 ;
27774 int res1 = 0 ;
27775 PyObject *swig_obj[1] ;
27776
27777 if (!args) SWIG_fail;
27778 swig_obj[0] = args;
27779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27780 if (!SWIG_IsOK(res1)) {
27781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27782 }
27783 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27784 {
27785 PyThreadState* __tstate = wxPyBeginAllowThreads();
27786 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27787 wxPyEndAllowThreads(__tstate);
27788 if (PyErr_Occurred()) SWIG_fail;
27789 }
27790 {
27791 resultobj = wxPyMake_wxObject(result, (bool)0);
27792 }
27793 return resultobj;
27794 fail:
27795 return NULL;
27796 }
27797
27798
27799 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27800 PyObject *resultobj = 0;
27801 wxPyApp *arg1 = (wxPyApp *) 0 ;
27802 bool arg2 ;
27803 void *argp1 = 0 ;
27804 int res1 = 0 ;
27805 bool val2 ;
27806 int ecode2 = 0 ;
27807 PyObject * obj0 = 0 ;
27808 PyObject * obj1 = 0 ;
27809 char * kwnames[] = {
27810 (char *) "self",(char *) "flag", NULL
27811 };
27812
27813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27815 if (!SWIG_IsOK(res1)) {
27816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27817 }
27818 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27819 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27820 if (!SWIG_IsOK(ecode2)) {
27821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27822 }
27823 arg2 = static_cast< bool >(val2);
27824 {
27825 PyThreadState* __tstate = wxPyBeginAllowThreads();
27826 (arg1)->SetExitOnFrameDelete(arg2);
27827 wxPyEndAllowThreads(__tstate);
27828 if (PyErr_Occurred()) SWIG_fail;
27829 }
27830 resultobj = SWIG_Py_Void();
27831 return resultobj;
27832 fail:
27833 return NULL;
27834 }
27835
27836
27837 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27838 PyObject *resultobj = 0;
27839 wxPyApp *arg1 = (wxPyApp *) 0 ;
27840 bool result;
27841 void *argp1 = 0 ;
27842 int res1 = 0 ;
27843 PyObject *swig_obj[1] ;
27844
27845 if (!args) SWIG_fail;
27846 swig_obj[0] = args;
27847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27848 if (!SWIG_IsOK(res1)) {
27849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27850 }
27851 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27852 {
27853 PyThreadState* __tstate = wxPyBeginAllowThreads();
27854 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27855 wxPyEndAllowThreads(__tstate);
27856 if (PyErr_Occurred()) SWIG_fail;
27857 }
27858 {
27859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27860 }
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27868 PyObject *resultobj = 0;
27869 wxPyApp *arg1 = (wxPyApp *) 0 ;
27870 bool arg2 ;
27871 void *argp1 = 0 ;
27872 int res1 = 0 ;
27873 bool val2 ;
27874 int ecode2 = 0 ;
27875 PyObject * obj0 = 0 ;
27876 PyObject * obj1 = 0 ;
27877 char * kwnames[] = {
27878 (char *) "self",(char *) "flag", NULL
27879 };
27880
27881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27883 if (!SWIG_IsOK(res1)) {
27884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27885 }
27886 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27887 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27888 if (!SWIG_IsOK(ecode2)) {
27889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27890 }
27891 arg2 = static_cast< bool >(val2);
27892 {
27893 PyThreadState* __tstate = wxPyBeginAllowThreads();
27894 (arg1)->SetUseBestVisual(arg2);
27895 wxPyEndAllowThreads(__tstate);
27896 if (PyErr_Occurred()) SWIG_fail;
27897 }
27898 resultobj = SWIG_Py_Void();
27899 return resultobj;
27900 fail:
27901 return NULL;
27902 }
27903
27904
27905 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27906 PyObject *resultobj = 0;
27907 wxPyApp *arg1 = (wxPyApp *) 0 ;
27908 bool result;
27909 void *argp1 = 0 ;
27910 int res1 = 0 ;
27911 PyObject *swig_obj[1] ;
27912
27913 if (!args) SWIG_fail;
27914 swig_obj[0] = args;
27915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27916 if (!SWIG_IsOK(res1)) {
27917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27918 }
27919 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27920 {
27921 PyThreadState* __tstate = wxPyBeginAllowThreads();
27922 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27923 wxPyEndAllowThreads(__tstate);
27924 if (PyErr_Occurred()) SWIG_fail;
27925 }
27926 {
27927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27928 }
27929 return resultobj;
27930 fail:
27931 return NULL;
27932 }
27933
27934
27935 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27936 PyObject *resultobj = 0;
27937 wxPyApp *arg1 = (wxPyApp *) 0 ;
27938 int arg2 ;
27939 void *argp1 = 0 ;
27940 int res1 = 0 ;
27941 int val2 ;
27942 int ecode2 = 0 ;
27943 PyObject * obj0 = 0 ;
27944 PyObject * obj1 = 0 ;
27945 char * kwnames[] = {
27946 (char *) "self",(char *) "mode", NULL
27947 };
27948
27949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27951 if (!SWIG_IsOK(res1)) {
27952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27953 }
27954 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27955 ecode2 = SWIG_AsVal_int(obj1, &val2);
27956 if (!SWIG_IsOK(ecode2)) {
27957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27958 }
27959 arg2 = static_cast< int >(val2);
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 (arg1)->SetPrintMode(arg2);
27963 wxPyEndAllowThreads(__tstate);
27964 if (PyErr_Occurred()) SWIG_fail;
27965 }
27966 resultobj = SWIG_Py_Void();
27967 return resultobj;
27968 fail:
27969 return NULL;
27970 }
27971
27972
27973 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27974 PyObject *resultobj = 0;
27975 wxPyApp *arg1 = (wxPyApp *) 0 ;
27976 int result;
27977 void *argp1 = 0 ;
27978 int res1 = 0 ;
27979 PyObject *swig_obj[1] ;
27980
27981 if (!args) SWIG_fail;
27982 swig_obj[0] = args;
27983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27984 if (!SWIG_IsOK(res1)) {
27985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27986 }
27987 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27988 {
27989 PyThreadState* __tstate = wxPyBeginAllowThreads();
27990 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27991 wxPyEndAllowThreads(__tstate);
27992 if (PyErr_Occurred()) SWIG_fail;
27993 }
27994 resultobj = SWIG_From_int(static_cast< int >(result));
27995 return resultobj;
27996 fail:
27997 return NULL;
27998 }
27999
28000
28001 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28002 PyObject *resultobj = 0;
28003 wxPyApp *arg1 = (wxPyApp *) 0 ;
28004 int arg2 ;
28005 void *argp1 = 0 ;
28006 int res1 = 0 ;
28007 int val2 ;
28008 int ecode2 = 0 ;
28009 PyObject * obj0 = 0 ;
28010 PyObject * obj1 = 0 ;
28011 char * kwnames[] = {
28012 (char *) "self",(char *) "mode", NULL
28013 };
28014
28015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28017 if (!SWIG_IsOK(res1)) {
28018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28019 }
28020 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28021 ecode2 = SWIG_AsVal_int(obj1, &val2);
28022 if (!SWIG_IsOK(ecode2)) {
28023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28024 }
28025 arg2 = static_cast< int >(val2);
28026 {
28027 PyThreadState* __tstate = wxPyBeginAllowThreads();
28028 (arg1)->SetAssertMode(arg2);
28029 wxPyEndAllowThreads(__tstate);
28030 if (PyErr_Occurred()) SWIG_fail;
28031 }
28032 resultobj = SWIG_Py_Void();
28033 return resultobj;
28034 fail:
28035 return NULL;
28036 }
28037
28038
28039 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28040 PyObject *resultobj = 0;
28041 wxPyApp *arg1 = (wxPyApp *) 0 ;
28042 int result;
28043 void *argp1 = 0 ;
28044 int res1 = 0 ;
28045 PyObject *swig_obj[1] ;
28046
28047 if (!args) SWIG_fail;
28048 swig_obj[0] = args;
28049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28050 if (!SWIG_IsOK(res1)) {
28051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28052 }
28053 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28054 {
28055 PyThreadState* __tstate = wxPyBeginAllowThreads();
28056 result = (int)(arg1)->GetAssertMode();
28057 wxPyEndAllowThreads(__tstate);
28058 if (PyErr_Occurred()) SWIG_fail;
28059 }
28060 resultobj = SWIG_From_int(static_cast< int >(result));
28061 return resultobj;
28062 fail:
28063 return NULL;
28064 }
28065
28066
28067 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28068 PyObject *resultobj = 0;
28069 bool result;
28070
28071 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28072 {
28073 PyThreadState* __tstate = wxPyBeginAllowThreads();
28074 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28075 wxPyEndAllowThreads(__tstate);
28076 if (PyErr_Occurred()) SWIG_fail;
28077 }
28078 {
28079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28080 }
28081 return resultobj;
28082 fail:
28083 return NULL;
28084 }
28085
28086
28087 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28088 PyObject *resultobj = 0;
28089 long result;
28090
28091 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28092 {
28093 PyThreadState* __tstate = wxPyBeginAllowThreads();
28094 result = (long)wxPyApp::GetMacAboutMenuItemId();
28095 wxPyEndAllowThreads(__tstate);
28096 if (PyErr_Occurred()) SWIG_fail;
28097 }
28098 resultobj = SWIG_From_long(static_cast< long >(result));
28099 return resultobj;
28100 fail:
28101 return NULL;
28102 }
28103
28104
28105 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28106 PyObject *resultobj = 0;
28107 long result;
28108
28109 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28110 {
28111 PyThreadState* __tstate = wxPyBeginAllowThreads();
28112 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28113 wxPyEndAllowThreads(__tstate);
28114 if (PyErr_Occurred()) SWIG_fail;
28115 }
28116 resultobj = SWIG_From_long(static_cast< long >(result));
28117 return resultobj;
28118 fail:
28119 return NULL;
28120 }
28121
28122
28123 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28124 PyObject *resultobj = 0;
28125 long result;
28126
28127 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28128 {
28129 PyThreadState* __tstate = wxPyBeginAllowThreads();
28130 result = (long)wxPyApp::GetMacExitMenuItemId();
28131 wxPyEndAllowThreads(__tstate);
28132 if (PyErr_Occurred()) SWIG_fail;
28133 }
28134 resultobj = SWIG_From_long(static_cast< long >(result));
28135 return resultobj;
28136 fail:
28137 return NULL;
28138 }
28139
28140
28141 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28142 PyObject *resultobj = 0;
28143 wxString result;
28144
28145 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28146 {
28147 PyThreadState* __tstate = wxPyBeginAllowThreads();
28148 result = wxPyApp::GetMacHelpMenuTitleName();
28149 wxPyEndAllowThreads(__tstate);
28150 if (PyErr_Occurred()) SWIG_fail;
28151 }
28152 {
28153 #if wxUSE_UNICODE
28154 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28155 #else
28156 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28157 #endif
28158 }
28159 return resultobj;
28160 fail:
28161 return NULL;
28162 }
28163
28164
28165 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28166 PyObject *resultobj = 0;
28167 bool arg1 ;
28168 bool val1 ;
28169 int ecode1 = 0 ;
28170 PyObject * obj0 = 0 ;
28171 char * kwnames[] = {
28172 (char *) "val", NULL
28173 };
28174
28175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28176 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28177 if (!SWIG_IsOK(ecode1)) {
28178 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28179 }
28180 arg1 = static_cast< bool >(val1);
28181 {
28182 PyThreadState* __tstate = wxPyBeginAllowThreads();
28183 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28184 wxPyEndAllowThreads(__tstate);
28185 if (PyErr_Occurred()) SWIG_fail;
28186 }
28187 resultobj = SWIG_Py_Void();
28188 return resultobj;
28189 fail:
28190 return NULL;
28191 }
28192
28193
28194 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28195 PyObject *resultobj = 0;
28196 long arg1 ;
28197 long val1 ;
28198 int ecode1 = 0 ;
28199 PyObject * obj0 = 0 ;
28200 char * kwnames[] = {
28201 (char *) "val", NULL
28202 };
28203
28204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28205 ecode1 = SWIG_AsVal_long(obj0, &val1);
28206 if (!SWIG_IsOK(ecode1)) {
28207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28208 }
28209 arg1 = static_cast< long >(val1);
28210 {
28211 PyThreadState* __tstate = wxPyBeginAllowThreads();
28212 wxPyApp::SetMacAboutMenuItemId(arg1);
28213 wxPyEndAllowThreads(__tstate);
28214 if (PyErr_Occurred()) SWIG_fail;
28215 }
28216 resultobj = SWIG_Py_Void();
28217 return resultobj;
28218 fail:
28219 return NULL;
28220 }
28221
28222
28223 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28224 PyObject *resultobj = 0;
28225 long arg1 ;
28226 long val1 ;
28227 int ecode1 = 0 ;
28228 PyObject * obj0 = 0 ;
28229 char * kwnames[] = {
28230 (char *) "val", NULL
28231 };
28232
28233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28234 ecode1 = SWIG_AsVal_long(obj0, &val1);
28235 if (!SWIG_IsOK(ecode1)) {
28236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28237 }
28238 arg1 = static_cast< long >(val1);
28239 {
28240 PyThreadState* __tstate = wxPyBeginAllowThreads();
28241 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28242 wxPyEndAllowThreads(__tstate);
28243 if (PyErr_Occurred()) SWIG_fail;
28244 }
28245 resultobj = SWIG_Py_Void();
28246 return resultobj;
28247 fail:
28248 return NULL;
28249 }
28250
28251
28252 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28253 PyObject *resultobj = 0;
28254 long arg1 ;
28255 long val1 ;
28256 int ecode1 = 0 ;
28257 PyObject * obj0 = 0 ;
28258 char * kwnames[] = {
28259 (char *) "val", NULL
28260 };
28261
28262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28263 ecode1 = SWIG_AsVal_long(obj0, &val1);
28264 if (!SWIG_IsOK(ecode1)) {
28265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28266 }
28267 arg1 = static_cast< long >(val1);
28268 {
28269 PyThreadState* __tstate = wxPyBeginAllowThreads();
28270 wxPyApp::SetMacExitMenuItemId(arg1);
28271 wxPyEndAllowThreads(__tstate);
28272 if (PyErr_Occurred()) SWIG_fail;
28273 }
28274 resultobj = SWIG_Py_Void();
28275 return resultobj;
28276 fail:
28277 return NULL;
28278 }
28279
28280
28281 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28282 PyObject *resultobj = 0;
28283 wxString *arg1 = 0 ;
28284 bool temp1 = false ;
28285 PyObject * obj0 = 0 ;
28286 char * kwnames[] = {
28287 (char *) "val", NULL
28288 };
28289
28290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28291 {
28292 arg1 = wxString_in_helper(obj0);
28293 if (arg1 == NULL) SWIG_fail;
28294 temp1 = true;
28295 }
28296 {
28297 PyThreadState* __tstate = wxPyBeginAllowThreads();
28298 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28299 wxPyEndAllowThreads(__tstate);
28300 if (PyErr_Occurred()) SWIG_fail;
28301 }
28302 resultobj = SWIG_Py_Void();
28303 {
28304 if (temp1)
28305 delete arg1;
28306 }
28307 return resultobj;
28308 fail:
28309 {
28310 if (temp1)
28311 delete arg1;
28312 }
28313 return NULL;
28314 }
28315
28316
28317 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28318 PyObject *resultobj = 0;
28319 wxPyApp *arg1 = (wxPyApp *) 0 ;
28320 void *argp1 = 0 ;
28321 int res1 = 0 ;
28322 PyObject *swig_obj[1] ;
28323
28324 if (!args) SWIG_fail;
28325 swig_obj[0] = args;
28326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28327 if (!SWIG_IsOK(res1)) {
28328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28329 }
28330 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28331 {
28332 PyThreadState* __tstate = wxPyBeginAllowThreads();
28333 (arg1)->_BootstrapApp();
28334 wxPyEndAllowThreads(__tstate);
28335 if (PyErr_Occurred()) SWIG_fail;
28336 }
28337 resultobj = SWIG_Py_Void();
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28345 PyObject *resultobj = 0;
28346 int result;
28347
28348 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28349 {
28350 PyThreadState* __tstate = wxPyBeginAllowThreads();
28351 result = (int)wxPyApp_GetComCtl32Version();
28352 wxPyEndAllowThreads(__tstate);
28353 if (PyErr_Occurred()) SWIG_fail;
28354 }
28355 resultobj = SWIG_From_int(static_cast< int >(result));
28356 return resultobj;
28357 fail:
28358 return NULL;
28359 }
28360
28361
28362 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28363 PyObject *obj;
28364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28365 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28366 return SWIG_Py_Void();
28367 }
28368
28369 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28370 return SWIG_Python_InitShadowInstance(args);
28371 }
28372
28373 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28374 PyObject *resultobj = 0;
28375
28376 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28377 {
28378 PyThreadState* __tstate = wxPyBeginAllowThreads();
28379 wxExit();
28380 wxPyEndAllowThreads(__tstate);
28381 if (PyErr_Occurred()) SWIG_fail;
28382 }
28383 resultobj = SWIG_Py_Void();
28384 return resultobj;
28385 fail:
28386 return NULL;
28387 }
28388
28389
28390 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28391 PyObject *resultobj = 0;
28392 bool result;
28393
28394 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28395 {
28396 PyThreadState* __tstate = wxPyBeginAllowThreads();
28397 result = (bool)wxYield();
28398 wxPyEndAllowThreads(__tstate);
28399 if (PyErr_Occurred()) SWIG_fail;
28400 }
28401 {
28402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28403 }
28404 return resultobj;
28405 fail:
28406 return NULL;
28407 }
28408
28409
28410 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28411 PyObject *resultobj = 0;
28412 bool result;
28413
28414 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28415 {
28416 PyThreadState* __tstate = wxPyBeginAllowThreads();
28417 result = (bool)wxYieldIfNeeded();
28418 wxPyEndAllowThreads(__tstate);
28419 if (PyErr_Occurred()) SWIG_fail;
28420 }
28421 {
28422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28423 }
28424 return resultobj;
28425 fail:
28426 return NULL;
28427 }
28428
28429
28430 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28431 PyObject *resultobj = 0;
28432 wxWindow *arg1 = (wxWindow *) NULL ;
28433 bool arg2 = (bool) false ;
28434 bool result;
28435 void *argp1 = 0 ;
28436 int res1 = 0 ;
28437 bool val2 ;
28438 int ecode2 = 0 ;
28439 PyObject * obj0 = 0 ;
28440 PyObject * obj1 = 0 ;
28441 char * kwnames[] = {
28442 (char *) "win",(char *) "onlyIfNeeded", NULL
28443 };
28444
28445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28446 if (obj0) {
28447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28448 if (!SWIG_IsOK(res1)) {
28449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28450 }
28451 arg1 = reinterpret_cast< wxWindow * >(argp1);
28452 }
28453 if (obj1) {
28454 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28455 if (!SWIG_IsOK(ecode2)) {
28456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28457 }
28458 arg2 = static_cast< bool >(val2);
28459 }
28460 {
28461 PyThreadState* __tstate = wxPyBeginAllowThreads();
28462 result = (bool)wxSafeYield(arg1,arg2);
28463 wxPyEndAllowThreads(__tstate);
28464 if (PyErr_Occurred()) SWIG_fail;
28465 }
28466 {
28467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28468 }
28469 return resultobj;
28470 fail:
28471 return NULL;
28472 }
28473
28474
28475 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28476 PyObject *resultobj = 0;
28477
28478 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28479 {
28480 PyThreadState* __tstate = wxPyBeginAllowThreads();
28481 wxWakeUpIdle();
28482 wxPyEndAllowThreads(__tstate);
28483 if (PyErr_Occurred()) SWIG_fail;
28484 }
28485 resultobj = SWIG_Py_Void();
28486 return resultobj;
28487 fail:
28488 return NULL;
28489 }
28490
28491
28492 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28493 PyObject *resultobj = 0;
28494 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28495 wxEvent *arg2 = 0 ;
28496 void *argp1 = 0 ;
28497 int res1 = 0 ;
28498 void *argp2 = 0 ;
28499 int res2 = 0 ;
28500 PyObject * obj0 = 0 ;
28501 PyObject * obj1 = 0 ;
28502 char * kwnames[] = {
28503 (char *) "dest",(char *) "event", NULL
28504 };
28505
28506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28508 if (!SWIG_IsOK(res1)) {
28509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28510 }
28511 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28512 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28513 if (!SWIG_IsOK(res2)) {
28514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28515 }
28516 if (!argp2) {
28517 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28518 }
28519 arg2 = reinterpret_cast< wxEvent * >(argp2);
28520 {
28521 PyThreadState* __tstate = wxPyBeginAllowThreads();
28522 wxPostEvent(arg1,*arg2);
28523 wxPyEndAllowThreads(__tstate);
28524 if (PyErr_Occurred()) SWIG_fail;
28525 }
28526 resultobj = SWIG_Py_Void();
28527 return resultobj;
28528 fail:
28529 return NULL;
28530 }
28531
28532
28533 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28534 PyObject *resultobj = 0;
28535
28536 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 wxApp_CleanUp();
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 resultobj = SWIG_Py_Void();
28544 return resultobj;
28545 fail:
28546 return NULL;
28547 }
28548
28549
28550 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28551 PyObject *resultobj = 0;
28552 wxPyApp *result = 0 ;
28553
28554 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28555 {
28556 PyThreadState* __tstate = wxPyBeginAllowThreads();
28557 result = (wxPyApp *)wxPyGetApp();
28558 wxPyEndAllowThreads(__tstate);
28559 if (PyErr_Occurred()) SWIG_fail;
28560 }
28561 {
28562 resultobj = wxPyMake_wxObject(result, 0);
28563 }
28564 return resultobj;
28565 fail:
28566 return NULL;
28567 }
28568
28569
28570 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28571 PyObject *resultobj = 0;
28572 char *arg1 = (char *) 0 ;
28573 int res1 ;
28574 char *buf1 = 0 ;
28575 int alloc1 = 0 ;
28576 PyObject * obj0 = 0 ;
28577 char * kwnames[] = {
28578 (char *) "encoding", NULL
28579 };
28580
28581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28582 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28583 if (!SWIG_IsOK(res1)) {
28584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28585 }
28586 arg1 = buf1;
28587 {
28588 PyThreadState* __tstate = wxPyBeginAllowThreads();
28589 wxSetDefaultPyEncoding((char const *)arg1);
28590 wxPyEndAllowThreads(__tstate);
28591 if (PyErr_Occurred()) SWIG_fail;
28592 }
28593 resultobj = SWIG_Py_Void();
28594 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28595 return resultobj;
28596 fail:
28597 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28598 return NULL;
28599 }
28600
28601
28602 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28603 PyObject *resultobj = 0;
28604 char *result = 0 ;
28605
28606 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28607 {
28608 PyThreadState* __tstate = wxPyBeginAllowThreads();
28609 result = (char *)wxGetDefaultPyEncoding();
28610 wxPyEndAllowThreads(__tstate);
28611 if (PyErr_Occurred()) SWIG_fail;
28612 }
28613 resultobj = SWIG_FromCharPtr(result);
28614 return resultobj;
28615 fail:
28616 return NULL;
28617 }
28618
28619
28620 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28621 PyObject *resultobj = 0;
28622 wxEventLoop *result = 0 ;
28623
28624 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28625 {
28626 PyThreadState* __tstate = wxPyBeginAllowThreads();
28627 result = (wxEventLoop *)new wxEventLoop();
28628 wxPyEndAllowThreads(__tstate);
28629 if (PyErr_Occurred()) SWIG_fail;
28630 }
28631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28632 return resultobj;
28633 fail:
28634 return NULL;
28635 }
28636
28637
28638 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28639 PyObject *resultobj = 0;
28640 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28641 void *argp1 = 0 ;
28642 int res1 = 0 ;
28643 PyObject *swig_obj[1] ;
28644
28645 if (!args) SWIG_fail;
28646 swig_obj[0] = args;
28647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28648 if (!SWIG_IsOK(res1)) {
28649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28650 }
28651 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28652 {
28653 PyThreadState* __tstate = wxPyBeginAllowThreads();
28654 delete arg1;
28655
28656 wxPyEndAllowThreads(__tstate);
28657 if (PyErr_Occurred()) SWIG_fail;
28658 }
28659 resultobj = SWIG_Py_Void();
28660 return resultobj;
28661 fail:
28662 return NULL;
28663 }
28664
28665
28666 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28667 PyObject *resultobj = 0;
28668 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28669 int result;
28670 void *argp1 = 0 ;
28671 int res1 = 0 ;
28672 PyObject *swig_obj[1] ;
28673
28674 if (!args) SWIG_fail;
28675 swig_obj[0] = args;
28676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28677 if (!SWIG_IsOK(res1)) {
28678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28679 }
28680 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28681 {
28682 PyThreadState* __tstate = wxPyBeginAllowThreads();
28683 result = (int)(arg1)->Run();
28684 wxPyEndAllowThreads(__tstate);
28685 if (PyErr_Occurred()) SWIG_fail;
28686 }
28687 resultobj = SWIG_From_int(static_cast< int >(result));
28688 return resultobj;
28689 fail:
28690 return NULL;
28691 }
28692
28693
28694 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28695 PyObject *resultobj = 0;
28696 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28697 int arg2 = (int) 0 ;
28698 void *argp1 = 0 ;
28699 int res1 = 0 ;
28700 int val2 ;
28701 int ecode2 = 0 ;
28702 PyObject * obj0 = 0 ;
28703 PyObject * obj1 = 0 ;
28704 char * kwnames[] = {
28705 (char *) "self",(char *) "rc", NULL
28706 };
28707
28708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28710 if (!SWIG_IsOK(res1)) {
28711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28712 }
28713 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28714 if (obj1) {
28715 ecode2 = SWIG_AsVal_int(obj1, &val2);
28716 if (!SWIG_IsOK(ecode2)) {
28717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28718 }
28719 arg2 = static_cast< int >(val2);
28720 }
28721 {
28722 PyThreadState* __tstate = wxPyBeginAllowThreads();
28723 (arg1)->Exit(arg2);
28724 wxPyEndAllowThreads(__tstate);
28725 if (PyErr_Occurred()) SWIG_fail;
28726 }
28727 resultobj = SWIG_Py_Void();
28728 return resultobj;
28729 fail:
28730 return NULL;
28731 }
28732
28733
28734 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28735 PyObject *resultobj = 0;
28736 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28737 bool result;
28738 void *argp1 = 0 ;
28739 int res1 = 0 ;
28740 PyObject *swig_obj[1] ;
28741
28742 if (!args) SWIG_fail;
28743 swig_obj[0] = args;
28744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28745 if (!SWIG_IsOK(res1)) {
28746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28747 }
28748 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28749 {
28750 PyThreadState* __tstate = wxPyBeginAllowThreads();
28751 result = (bool)((wxEventLoop const *)arg1)->Pending();
28752 wxPyEndAllowThreads(__tstate);
28753 if (PyErr_Occurred()) SWIG_fail;
28754 }
28755 {
28756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28757 }
28758 return resultobj;
28759 fail:
28760 return NULL;
28761 }
28762
28763
28764 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28765 PyObject *resultobj = 0;
28766 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28767 bool result;
28768 void *argp1 = 0 ;
28769 int res1 = 0 ;
28770 PyObject *swig_obj[1] ;
28771
28772 if (!args) SWIG_fail;
28773 swig_obj[0] = args;
28774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28775 if (!SWIG_IsOK(res1)) {
28776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28777 }
28778 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28779 {
28780 PyThreadState* __tstate = wxPyBeginAllowThreads();
28781 result = (bool)(arg1)->Dispatch();
28782 wxPyEndAllowThreads(__tstate);
28783 if (PyErr_Occurred()) SWIG_fail;
28784 }
28785 {
28786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28787 }
28788 return resultobj;
28789 fail:
28790 return NULL;
28791 }
28792
28793
28794 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28795 PyObject *resultobj = 0;
28796 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28797 bool result;
28798 void *argp1 = 0 ;
28799 int res1 = 0 ;
28800 PyObject *swig_obj[1] ;
28801
28802 if (!args) SWIG_fail;
28803 swig_obj[0] = args;
28804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28805 if (!SWIG_IsOK(res1)) {
28806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28807 }
28808 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28809 {
28810 PyThreadState* __tstate = wxPyBeginAllowThreads();
28811 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28812 wxPyEndAllowThreads(__tstate);
28813 if (PyErr_Occurred()) SWIG_fail;
28814 }
28815 {
28816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28817 }
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28825 PyObject *resultobj = 0;
28826 wxEventLoop *result = 0 ;
28827
28828 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 result = (wxEventLoop *)wxEventLoop::GetActive();
28832 wxPyEndAllowThreads(__tstate);
28833 if (PyErr_Occurred()) SWIG_fail;
28834 }
28835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28836 return resultobj;
28837 fail:
28838 return NULL;
28839 }
28840
28841
28842 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28843 PyObject *resultobj = 0;
28844 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28845 void *argp1 = 0 ;
28846 int res1 = 0 ;
28847 PyObject * obj0 = 0 ;
28848 char * kwnames[] = {
28849 (char *) "loop", NULL
28850 };
28851
28852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28854 if (!SWIG_IsOK(res1)) {
28855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28856 }
28857 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28858 {
28859 PyThreadState* __tstate = wxPyBeginAllowThreads();
28860 wxEventLoop::SetActive(arg1);
28861 wxPyEndAllowThreads(__tstate);
28862 if (PyErr_Occurred()) SWIG_fail;
28863 }
28864 resultobj = SWIG_Py_Void();
28865 return resultobj;
28866 fail:
28867 return NULL;
28868 }
28869
28870
28871 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28872 PyObject *obj;
28873 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28874 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28875 return SWIG_Py_Void();
28876 }
28877
28878 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28879 return SWIG_Python_InitShadowInstance(args);
28880 }
28881
28882 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28883 PyObject *resultobj = 0;
28884 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28885 wxEventLoopActivator *result = 0 ;
28886 void *argp1 = 0 ;
28887 int res1 = 0 ;
28888 PyObject * obj0 = 0 ;
28889 char * kwnames[] = {
28890 (char *) "evtLoop", NULL
28891 };
28892
28893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28895 if (!SWIG_IsOK(res1)) {
28896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28897 }
28898 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28899 {
28900 PyThreadState* __tstate = wxPyBeginAllowThreads();
28901 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28902 wxPyEndAllowThreads(__tstate);
28903 if (PyErr_Occurred()) SWIG_fail;
28904 }
28905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28906 return resultobj;
28907 fail:
28908 return NULL;
28909 }
28910
28911
28912 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28913 PyObject *resultobj = 0;
28914 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28915 void *argp1 = 0 ;
28916 int res1 = 0 ;
28917 PyObject *swig_obj[1] ;
28918
28919 if (!args) SWIG_fail;
28920 swig_obj[0] = args;
28921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28922 if (!SWIG_IsOK(res1)) {
28923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28924 }
28925 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 delete arg1;
28929
28930 wxPyEndAllowThreads(__tstate);
28931 if (PyErr_Occurred()) SWIG_fail;
28932 }
28933 resultobj = SWIG_Py_Void();
28934 return resultobj;
28935 fail:
28936 return NULL;
28937 }
28938
28939
28940 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28941 PyObject *obj;
28942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28943 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28944 return SWIG_Py_Void();
28945 }
28946
28947 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28948 return SWIG_Python_InitShadowInstance(args);
28949 }
28950
28951 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28952 PyObject *resultobj = 0;
28953 int arg1 = (int) 0 ;
28954 int arg2 = (int) 0 ;
28955 int arg3 = (int) 0 ;
28956 wxAcceleratorEntry *result = 0 ;
28957 int val1 ;
28958 int ecode1 = 0 ;
28959 int val2 ;
28960 int ecode2 = 0 ;
28961 int val3 ;
28962 int ecode3 = 0 ;
28963 PyObject * obj0 = 0 ;
28964 PyObject * obj1 = 0 ;
28965 PyObject * obj2 = 0 ;
28966 char * kwnames[] = {
28967 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28968 };
28969
28970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28971 if (obj0) {
28972 ecode1 = SWIG_AsVal_int(obj0, &val1);
28973 if (!SWIG_IsOK(ecode1)) {
28974 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28975 }
28976 arg1 = static_cast< int >(val1);
28977 }
28978 if (obj1) {
28979 ecode2 = SWIG_AsVal_int(obj1, &val2);
28980 if (!SWIG_IsOK(ecode2)) {
28981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28982 }
28983 arg2 = static_cast< int >(val2);
28984 }
28985 if (obj2) {
28986 ecode3 = SWIG_AsVal_int(obj2, &val3);
28987 if (!SWIG_IsOK(ecode3)) {
28988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28989 }
28990 arg3 = static_cast< int >(val3);
28991 }
28992 {
28993 PyThreadState* __tstate = wxPyBeginAllowThreads();
28994 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28995 wxPyEndAllowThreads(__tstate);
28996 if (PyErr_Occurred()) SWIG_fail;
28997 }
28998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28999 return resultobj;
29000 fail:
29001 return NULL;
29002 }
29003
29004
29005 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29006 PyObject *resultobj = 0;
29007 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29008 void *argp1 = 0 ;
29009 int res1 = 0 ;
29010 PyObject *swig_obj[1] ;
29011
29012 if (!args) SWIG_fail;
29013 swig_obj[0] = args;
29014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29015 if (!SWIG_IsOK(res1)) {
29016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29017 }
29018 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29019 {
29020 PyThreadState* __tstate = wxPyBeginAllowThreads();
29021 delete arg1;
29022
29023 wxPyEndAllowThreads(__tstate);
29024 if (PyErr_Occurred()) SWIG_fail;
29025 }
29026 resultobj = SWIG_Py_Void();
29027 return resultobj;
29028 fail:
29029 return NULL;
29030 }
29031
29032
29033 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29034 PyObject *resultobj = 0;
29035 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29036 int arg2 ;
29037 int arg3 ;
29038 int arg4 ;
29039 void *argp1 = 0 ;
29040 int res1 = 0 ;
29041 int val2 ;
29042 int ecode2 = 0 ;
29043 int val3 ;
29044 int ecode3 = 0 ;
29045 int val4 ;
29046 int ecode4 = 0 ;
29047 PyObject * obj0 = 0 ;
29048 PyObject * obj1 = 0 ;
29049 PyObject * obj2 = 0 ;
29050 PyObject * obj3 = 0 ;
29051 char * kwnames[] = {
29052 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29053 };
29054
29055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29057 if (!SWIG_IsOK(res1)) {
29058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29059 }
29060 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29061 ecode2 = SWIG_AsVal_int(obj1, &val2);
29062 if (!SWIG_IsOK(ecode2)) {
29063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29064 }
29065 arg2 = static_cast< int >(val2);
29066 ecode3 = SWIG_AsVal_int(obj2, &val3);
29067 if (!SWIG_IsOK(ecode3)) {
29068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29069 }
29070 arg3 = static_cast< int >(val3);
29071 ecode4 = SWIG_AsVal_int(obj3, &val4);
29072 if (!SWIG_IsOK(ecode4)) {
29073 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29074 }
29075 arg4 = static_cast< int >(val4);
29076 {
29077 PyThreadState* __tstate = wxPyBeginAllowThreads();
29078 (arg1)->Set(arg2,arg3,arg4);
29079 wxPyEndAllowThreads(__tstate);
29080 if (PyErr_Occurred()) SWIG_fail;
29081 }
29082 resultobj = SWIG_Py_Void();
29083 return resultobj;
29084 fail:
29085 return NULL;
29086 }
29087
29088
29089 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29090 PyObject *resultobj = 0;
29091 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29092 int result;
29093 void *argp1 = 0 ;
29094 int res1 = 0 ;
29095 PyObject *swig_obj[1] ;
29096
29097 if (!args) SWIG_fail;
29098 swig_obj[0] = args;
29099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29100 if (!SWIG_IsOK(res1)) {
29101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29102 }
29103 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29104 {
29105 PyThreadState* __tstate = wxPyBeginAllowThreads();
29106 result = (int)(arg1)->GetFlags();
29107 wxPyEndAllowThreads(__tstate);
29108 if (PyErr_Occurred()) SWIG_fail;
29109 }
29110 resultobj = SWIG_From_int(static_cast< int >(result));
29111 return resultobj;
29112 fail:
29113 return NULL;
29114 }
29115
29116
29117 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29118 PyObject *resultobj = 0;
29119 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29120 int result;
29121 void *argp1 = 0 ;
29122 int res1 = 0 ;
29123 PyObject *swig_obj[1] ;
29124
29125 if (!args) SWIG_fail;
29126 swig_obj[0] = args;
29127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29128 if (!SWIG_IsOK(res1)) {
29129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29130 }
29131 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29132 {
29133 PyThreadState* __tstate = wxPyBeginAllowThreads();
29134 result = (int)(arg1)->GetKeyCode();
29135 wxPyEndAllowThreads(__tstate);
29136 if (PyErr_Occurred()) SWIG_fail;
29137 }
29138 resultobj = SWIG_From_int(static_cast< int >(result));
29139 return resultobj;
29140 fail:
29141 return NULL;
29142 }
29143
29144
29145 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29146 PyObject *resultobj = 0;
29147 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29148 int result;
29149 void *argp1 = 0 ;
29150 int res1 = 0 ;
29151 PyObject *swig_obj[1] ;
29152
29153 if (!args) SWIG_fail;
29154 swig_obj[0] = args;
29155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29156 if (!SWIG_IsOK(res1)) {
29157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29158 }
29159 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29160 {
29161 PyThreadState* __tstate = wxPyBeginAllowThreads();
29162 result = (int)(arg1)->GetCommand();
29163 wxPyEndAllowThreads(__tstate);
29164 if (PyErr_Occurred()) SWIG_fail;
29165 }
29166 resultobj = SWIG_From_int(static_cast< int >(result));
29167 return resultobj;
29168 fail:
29169 return NULL;
29170 }
29171
29172
29173 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29174 PyObject *obj;
29175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29176 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29177 return SWIG_Py_Void();
29178 }
29179
29180 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29181 return SWIG_Python_InitShadowInstance(args);
29182 }
29183
29184 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29185 PyObject *resultobj = 0;
29186 int arg1 ;
29187 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29188 wxAcceleratorTable *result = 0 ;
29189 PyObject * obj0 = 0 ;
29190 char * kwnames[] = {
29191 (char *) "n", NULL
29192 };
29193
29194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29195 {
29196 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29197 if (arg2) arg1 = PyList_Size(obj0);
29198 else arg1 = 0;
29199 }
29200 {
29201 PyThreadState* __tstate = wxPyBeginAllowThreads();
29202 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29203 wxPyEndAllowThreads(__tstate);
29204 if (PyErr_Occurred()) SWIG_fail;
29205 }
29206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29207 return resultobj;
29208 fail:
29209 return NULL;
29210 }
29211
29212
29213 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29214 PyObject *resultobj = 0;
29215 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29216 void *argp1 = 0 ;
29217 int res1 = 0 ;
29218 PyObject *swig_obj[1] ;
29219
29220 if (!args) SWIG_fail;
29221 swig_obj[0] = args;
29222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29223 if (!SWIG_IsOK(res1)) {
29224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29225 }
29226 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29227 {
29228 PyThreadState* __tstate = wxPyBeginAllowThreads();
29229 delete arg1;
29230
29231 wxPyEndAllowThreads(__tstate);
29232 if (PyErr_Occurred()) SWIG_fail;
29233 }
29234 resultobj = SWIG_Py_Void();
29235 return resultobj;
29236 fail:
29237 return NULL;
29238 }
29239
29240
29241 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29242 PyObject *resultobj = 0;
29243 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29244 bool result;
29245 void *argp1 = 0 ;
29246 int res1 = 0 ;
29247 PyObject *swig_obj[1] ;
29248
29249 if (!args) SWIG_fail;
29250 swig_obj[0] = args;
29251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29252 if (!SWIG_IsOK(res1)) {
29253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29254 }
29255 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29256 {
29257 PyThreadState* __tstate = wxPyBeginAllowThreads();
29258 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29259 wxPyEndAllowThreads(__tstate);
29260 if (PyErr_Occurred()) SWIG_fail;
29261 }
29262 {
29263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29264 }
29265 return resultobj;
29266 fail:
29267 return NULL;
29268 }
29269
29270
29271 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29272 PyObject *obj;
29273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29274 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29275 return SWIG_Py_Void();
29276 }
29277
29278 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29279 return SWIG_Python_InitShadowInstance(args);
29280 }
29281
29282 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29283 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29284 return 1;
29285 }
29286
29287
29288 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29289 PyObject *pyobj = 0;
29290
29291 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29292 return pyobj;
29293 }
29294
29295
29296 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29297 PyObject *resultobj = 0;
29298 wxString *arg1 = 0 ;
29299 wxAcceleratorEntry *result = 0 ;
29300 bool temp1 = false ;
29301 PyObject * obj0 = 0 ;
29302 char * kwnames[] = {
29303 (char *) "label", NULL
29304 };
29305
29306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29307 {
29308 arg1 = wxString_in_helper(obj0);
29309 if (arg1 == NULL) SWIG_fail;
29310 temp1 = true;
29311 }
29312 {
29313 PyThreadState* __tstate = wxPyBeginAllowThreads();
29314 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29315 wxPyEndAllowThreads(__tstate);
29316 if (PyErr_Occurred()) SWIG_fail;
29317 }
29318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29319 {
29320 if (temp1)
29321 delete arg1;
29322 }
29323 return resultobj;
29324 fail:
29325 {
29326 if (temp1)
29327 delete arg1;
29328 }
29329 return NULL;
29330 }
29331
29332
29333 SWIGINTERN int PanelNameStr_set(PyObject *) {
29334 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29335 return 1;
29336 }
29337
29338
29339 SWIGINTERN PyObject *PanelNameStr_get(void) {
29340 PyObject *pyobj = 0;
29341
29342 {
29343 #if wxUSE_UNICODE
29344 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29345 #else
29346 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29347 #endif
29348 }
29349 return pyobj;
29350 }
29351
29352
29353 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29354 PyObject *resultobj = 0;
29355 wxVisualAttributes *result = 0 ;
29356
29357 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29358 {
29359 PyThreadState* __tstate = wxPyBeginAllowThreads();
29360 result = (wxVisualAttributes *)new_wxVisualAttributes();
29361 wxPyEndAllowThreads(__tstate);
29362 if (PyErr_Occurred()) SWIG_fail;
29363 }
29364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29365 return resultobj;
29366 fail:
29367 return NULL;
29368 }
29369
29370
29371 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29372 PyObject *resultobj = 0;
29373 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29374 void *argp1 = 0 ;
29375 int res1 = 0 ;
29376 PyObject *swig_obj[1] ;
29377
29378 if (!args) SWIG_fail;
29379 swig_obj[0] = args;
29380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29381 if (!SWIG_IsOK(res1)) {
29382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29383 }
29384 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29385 {
29386 PyThreadState* __tstate = wxPyBeginAllowThreads();
29387 delete_wxVisualAttributes(arg1);
29388
29389 wxPyEndAllowThreads(__tstate);
29390 if (PyErr_Occurred()) SWIG_fail;
29391 }
29392 resultobj = SWIG_Py_Void();
29393 return resultobj;
29394 fail:
29395 return NULL;
29396 }
29397
29398
29399 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29400 PyObject *resultobj = 0;
29401 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29402 wxFont *arg2 = (wxFont *) 0 ;
29403 void *argp1 = 0 ;
29404 int res1 = 0 ;
29405 void *argp2 = 0 ;
29406 int res2 = 0 ;
29407 PyObject *swig_obj[2] ;
29408
29409 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29411 if (!SWIG_IsOK(res1)) {
29412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29413 }
29414 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29415 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29416 if (!SWIG_IsOK(res2)) {
29417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29418 }
29419 arg2 = reinterpret_cast< wxFont * >(argp2);
29420 if (arg1) (arg1)->font = *arg2;
29421
29422 resultobj = SWIG_Py_Void();
29423 return resultobj;
29424 fail:
29425 return NULL;
29426 }
29427
29428
29429 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29430 PyObject *resultobj = 0;
29431 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29432 wxFont *result = 0 ;
29433 void *argp1 = 0 ;
29434 int res1 = 0 ;
29435 PyObject *swig_obj[1] ;
29436
29437 if (!args) SWIG_fail;
29438 swig_obj[0] = args;
29439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29440 if (!SWIG_IsOK(res1)) {
29441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29442 }
29443 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29444 result = (wxFont *)& ((arg1)->font);
29445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29446 return resultobj;
29447 fail:
29448 return NULL;
29449 }
29450
29451
29452 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29453 PyObject *resultobj = 0;
29454 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29455 wxColour *arg2 = (wxColour *) 0 ;
29456 void *argp1 = 0 ;
29457 int res1 = 0 ;
29458 void *argp2 = 0 ;
29459 int res2 = 0 ;
29460 PyObject *swig_obj[2] ;
29461
29462 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29464 if (!SWIG_IsOK(res1)) {
29465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29466 }
29467 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29468 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29469 if (!SWIG_IsOK(res2)) {
29470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29471 }
29472 arg2 = reinterpret_cast< wxColour * >(argp2);
29473 if (arg1) (arg1)->colFg = *arg2;
29474
29475 resultobj = SWIG_Py_Void();
29476 return resultobj;
29477 fail:
29478 return NULL;
29479 }
29480
29481
29482 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29483 PyObject *resultobj = 0;
29484 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29485 wxColour *result = 0 ;
29486 void *argp1 = 0 ;
29487 int res1 = 0 ;
29488 PyObject *swig_obj[1] ;
29489
29490 if (!args) SWIG_fail;
29491 swig_obj[0] = args;
29492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29493 if (!SWIG_IsOK(res1)) {
29494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29495 }
29496 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29497 result = (wxColour *)& ((arg1)->colFg);
29498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29499 return resultobj;
29500 fail:
29501 return NULL;
29502 }
29503
29504
29505 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29506 PyObject *resultobj = 0;
29507 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29508 wxColour *arg2 = (wxColour *) 0 ;
29509 void *argp1 = 0 ;
29510 int res1 = 0 ;
29511 void *argp2 = 0 ;
29512 int res2 = 0 ;
29513 PyObject *swig_obj[2] ;
29514
29515 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29517 if (!SWIG_IsOK(res1)) {
29518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29519 }
29520 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29521 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29522 if (!SWIG_IsOK(res2)) {
29523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29524 }
29525 arg2 = reinterpret_cast< wxColour * >(argp2);
29526 if (arg1) (arg1)->colBg = *arg2;
29527
29528 resultobj = SWIG_Py_Void();
29529 return resultobj;
29530 fail:
29531 return NULL;
29532 }
29533
29534
29535 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29536 PyObject *resultobj = 0;
29537 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29538 wxColour *result = 0 ;
29539 void *argp1 = 0 ;
29540 int res1 = 0 ;
29541 PyObject *swig_obj[1] ;
29542
29543 if (!args) SWIG_fail;
29544 swig_obj[0] = args;
29545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29546 if (!SWIG_IsOK(res1)) {
29547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29548 }
29549 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29550 result = (wxColour *)& ((arg1)->colBg);
29551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29552 return resultobj;
29553 fail:
29554 return NULL;
29555 }
29556
29557
29558 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29559 PyObject *obj;
29560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29561 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29562 return SWIG_Py_Void();
29563 }
29564
29565 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29566 return SWIG_Python_InitShadowInstance(args);
29567 }
29568
29569 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29570 PyObject *resultobj = 0;
29571 wxWindow *arg1 = (wxWindow *) 0 ;
29572 int arg2 = (int) (int)-1 ;
29573 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29574 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29575 wxSize const &arg4_defvalue = wxDefaultSize ;
29576 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29577 long arg5 = (long) 0 ;
29578 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29579 wxString *arg6 = (wxString *) &arg6_defvalue ;
29580 wxWindow *result = 0 ;
29581 void *argp1 = 0 ;
29582 int res1 = 0 ;
29583 int val2 ;
29584 int ecode2 = 0 ;
29585 wxPoint temp3 ;
29586 wxSize temp4 ;
29587 long val5 ;
29588 int ecode5 = 0 ;
29589 bool temp6 = false ;
29590 PyObject * obj0 = 0 ;
29591 PyObject * obj1 = 0 ;
29592 PyObject * obj2 = 0 ;
29593 PyObject * obj3 = 0 ;
29594 PyObject * obj4 = 0 ;
29595 PyObject * obj5 = 0 ;
29596 char * kwnames[] = {
29597 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29598 };
29599
29600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29602 if (!SWIG_IsOK(res1)) {
29603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29604 }
29605 arg1 = reinterpret_cast< wxWindow * >(argp1);
29606 if (obj1) {
29607 ecode2 = SWIG_AsVal_int(obj1, &val2);
29608 if (!SWIG_IsOK(ecode2)) {
29609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29610 }
29611 arg2 = static_cast< int >(val2);
29612 }
29613 if (obj2) {
29614 {
29615 arg3 = &temp3;
29616 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29617 }
29618 }
29619 if (obj3) {
29620 {
29621 arg4 = &temp4;
29622 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29623 }
29624 }
29625 if (obj4) {
29626 ecode5 = SWIG_AsVal_long(obj4, &val5);
29627 if (!SWIG_IsOK(ecode5)) {
29628 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29629 }
29630 arg5 = static_cast< long >(val5);
29631 }
29632 if (obj5) {
29633 {
29634 arg6 = wxString_in_helper(obj5);
29635 if (arg6 == NULL) SWIG_fail;
29636 temp6 = true;
29637 }
29638 }
29639 {
29640 if (!wxPyCheckForApp()) SWIG_fail;
29641 PyThreadState* __tstate = wxPyBeginAllowThreads();
29642 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29643 wxPyEndAllowThreads(__tstate);
29644 if (PyErr_Occurred()) SWIG_fail;
29645 }
29646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29647 {
29648 if (temp6)
29649 delete arg6;
29650 }
29651 return resultobj;
29652 fail:
29653 {
29654 if (temp6)
29655 delete arg6;
29656 }
29657 return NULL;
29658 }
29659
29660
29661 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29662 PyObject *resultobj = 0;
29663 wxWindow *result = 0 ;
29664
29665 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29666 {
29667 if (!wxPyCheckForApp()) SWIG_fail;
29668 PyThreadState* __tstate = wxPyBeginAllowThreads();
29669 result = (wxWindow *)new wxWindow();
29670 wxPyEndAllowThreads(__tstate);
29671 if (PyErr_Occurred()) SWIG_fail;
29672 }
29673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29674 return resultobj;
29675 fail:
29676 return NULL;
29677 }
29678
29679
29680 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29681 PyObject *resultobj = 0;
29682 wxWindow *arg1 = (wxWindow *) 0 ;
29683 wxWindow *arg2 = (wxWindow *) 0 ;
29684 int arg3 = (int) (int)-1 ;
29685 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29686 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29687 wxSize const &arg5_defvalue = wxDefaultSize ;
29688 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29689 long arg6 = (long) 0 ;
29690 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29691 wxString *arg7 = (wxString *) &arg7_defvalue ;
29692 bool result;
29693 void *argp1 = 0 ;
29694 int res1 = 0 ;
29695 void *argp2 = 0 ;
29696 int res2 = 0 ;
29697 int val3 ;
29698 int ecode3 = 0 ;
29699 wxPoint temp4 ;
29700 wxSize temp5 ;
29701 long val6 ;
29702 int ecode6 = 0 ;
29703 bool temp7 = false ;
29704 PyObject * obj0 = 0 ;
29705 PyObject * obj1 = 0 ;
29706 PyObject * obj2 = 0 ;
29707 PyObject * obj3 = 0 ;
29708 PyObject * obj4 = 0 ;
29709 PyObject * obj5 = 0 ;
29710 PyObject * obj6 = 0 ;
29711 char * kwnames[] = {
29712 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29713 };
29714
29715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29717 if (!SWIG_IsOK(res1)) {
29718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29719 }
29720 arg1 = reinterpret_cast< wxWindow * >(argp1);
29721 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29722 if (!SWIG_IsOK(res2)) {
29723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29724 }
29725 arg2 = reinterpret_cast< wxWindow * >(argp2);
29726 if (obj2) {
29727 ecode3 = SWIG_AsVal_int(obj2, &val3);
29728 if (!SWIG_IsOK(ecode3)) {
29729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29730 }
29731 arg3 = static_cast< int >(val3);
29732 }
29733 if (obj3) {
29734 {
29735 arg4 = &temp4;
29736 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29737 }
29738 }
29739 if (obj4) {
29740 {
29741 arg5 = &temp5;
29742 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29743 }
29744 }
29745 if (obj5) {
29746 ecode6 = SWIG_AsVal_long(obj5, &val6);
29747 if (!SWIG_IsOK(ecode6)) {
29748 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29749 }
29750 arg6 = static_cast< long >(val6);
29751 }
29752 if (obj6) {
29753 {
29754 arg7 = wxString_in_helper(obj6);
29755 if (arg7 == NULL) SWIG_fail;
29756 temp7 = true;
29757 }
29758 }
29759 {
29760 PyThreadState* __tstate = wxPyBeginAllowThreads();
29761 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29762 wxPyEndAllowThreads(__tstate);
29763 if (PyErr_Occurred()) SWIG_fail;
29764 }
29765 {
29766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29767 }
29768 {
29769 if (temp7)
29770 delete arg7;
29771 }
29772 return resultobj;
29773 fail:
29774 {
29775 if (temp7)
29776 delete arg7;
29777 }
29778 return NULL;
29779 }
29780
29781
29782 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29783 PyObject *resultobj = 0;
29784 wxWindow *arg1 = (wxWindow *) 0 ;
29785 bool arg2 = (bool) false ;
29786 bool result;
29787 void *argp1 = 0 ;
29788 int res1 = 0 ;
29789 bool val2 ;
29790 int ecode2 = 0 ;
29791 PyObject * obj0 = 0 ;
29792 PyObject * obj1 = 0 ;
29793 char * kwnames[] = {
29794 (char *) "self",(char *) "force", NULL
29795 };
29796
29797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29799 if (!SWIG_IsOK(res1)) {
29800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29801 }
29802 arg1 = reinterpret_cast< wxWindow * >(argp1);
29803 if (obj1) {
29804 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29805 if (!SWIG_IsOK(ecode2)) {
29806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29807 }
29808 arg2 = static_cast< bool >(val2);
29809 }
29810 {
29811 PyThreadState* __tstate = wxPyBeginAllowThreads();
29812 result = (bool)(arg1)->Close(arg2);
29813 wxPyEndAllowThreads(__tstate);
29814 if (PyErr_Occurred()) SWIG_fail;
29815 }
29816 {
29817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29818 }
29819 return resultobj;
29820 fail:
29821 return NULL;
29822 }
29823
29824
29825 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29826 PyObject *resultobj = 0;
29827 wxWindow *arg1 = (wxWindow *) 0 ;
29828 bool result;
29829 void *argp1 = 0 ;
29830 int res1 = 0 ;
29831 PyObject *swig_obj[1] ;
29832
29833 if (!args) SWIG_fail;
29834 swig_obj[0] = args;
29835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29836 if (!SWIG_IsOK(res1)) {
29837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29838 }
29839 arg1 = reinterpret_cast< wxWindow * >(argp1);
29840 {
29841 PyThreadState* __tstate = wxPyBeginAllowThreads();
29842 result = (bool)(arg1)->Destroy();
29843 wxPyEndAllowThreads(__tstate);
29844 if (PyErr_Occurred()) SWIG_fail;
29845 }
29846 {
29847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29848 }
29849 return resultobj;
29850 fail:
29851 return NULL;
29852 }
29853
29854
29855 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29856 PyObject *resultobj = 0;
29857 wxWindow *arg1 = (wxWindow *) 0 ;
29858 bool result;
29859 void *argp1 = 0 ;
29860 int res1 = 0 ;
29861 PyObject *swig_obj[1] ;
29862
29863 if (!args) SWIG_fail;
29864 swig_obj[0] = args;
29865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29866 if (!SWIG_IsOK(res1)) {
29867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29868 }
29869 arg1 = reinterpret_cast< wxWindow * >(argp1);
29870 {
29871 PyThreadState* __tstate = wxPyBeginAllowThreads();
29872 result = (bool)(arg1)->DestroyChildren();
29873 wxPyEndAllowThreads(__tstate);
29874 if (PyErr_Occurred()) SWIG_fail;
29875 }
29876 {
29877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29878 }
29879 return resultobj;
29880 fail:
29881 return NULL;
29882 }
29883
29884
29885 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29886 PyObject *resultobj = 0;
29887 wxWindow *arg1 = (wxWindow *) 0 ;
29888 bool result;
29889 void *argp1 = 0 ;
29890 int res1 = 0 ;
29891 PyObject *swig_obj[1] ;
29892
29893 if (!args) SWIG_fail;
29894 swig_obj[0] = args;
29895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29896 if (!SWIG_IsOK(res1)) {
29897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29898 }
29899 arg1 = reinterpret_cast< wxWindow * >(argp1);
29900 {
29901 PyThreadState* __tstate = wxPyBeginAllowThreads();
29902 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29903 wxPyEndAllowThreads(__tstate);
29904 if (PyErr_Occurred()) SWIG_fail;
29905 }
29906 {
29907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29908 }
29909 return resultobj;
29910 fail:
29911 return NULL;
29912 }
29913
29914
29915 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29916 PyObject *resultobj = 0;
29917 wxWindow *arg1 = (wxWindow *) 0 ;
29918 wxString *arg2 = 0 ;
29919 void *argp1 = 0 ;
29920 int res1 = 0 ;
29921 bool temp2 = false ;
29922 PyObject * obj0 = 0 ;
29923 PyObject * obj1 = 0 ;
29924 char * kwnames[] = {
29925 (char *) "self",(char *) "label", NULL
29926 };
29927
29928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29930 if (!SWIG_IsOK(res1)) {
29931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29932 }
29933 arg1 = reinterpret_cast< wxWindow * >(argp1);
29934 {
29935 arg2 = wxString_in_helper(obj1);
29936 if (arg2 == NULL) SWIG_fail;
29937 temp2 = true;
29938 }
29939 {
29940 PyThreadState* __tstate = wxPyBeginAllowThreads();
29941 (arg1)->SetLabel((wxString const &)*arg2);
29942 wxPyEndAllowThreads(__tstate);
29943 if (PyErr_Occurred()) SWIG_fail;
29944 }
29945 resultobj = SWIG_Py_Void();
29946 {
29947 if (temp2)
29948 delete arg2;
29949 }
29950 return resultobj;
29951 fail:
29952 {
29953 if (temp2)
29954 delete arg2;
29955 }
29956 return NULL;
29957 }
29958
29959
29960 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29961 PyObject *resultobj = 0;
29962 wxWindow *arg1 = (wxWindow *) 0 ;
29963 wxString result;
29964 void *argp1 = 0 ;
29965 int res1 = 0 ;
29966 PyObject *swig_obj[1] ;
29967
29968 if (!args) SWIG_fail;
29969 swig_obj[0] = args;
29970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29971 if (!SWIG_IsOK(res1)) {
29972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29973 }
29974 arg1 = reinterpret_cast< wxWindow * >(argp1);
29975 {
29976 PyThreadState* __tstate = wxPyBeginAllowThreads();
29977 result = ((wxWindow const *)arg1)->GetLabel();
29978 wxPyEndAllowThreads(__tstate);
29979 if (PyErr_Occurred()) SWIG_fail;
29980 }
29981 {
29982 #if wxUSE_UNICODE
29983 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29984 #else
29985 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29986 #endif
29987 }
29988 return resultobj;
29989 fail:
29990 return NULL;
29991 }
29992
29993
29994 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29995 PyObject *resultobj = 0;
29996 wxWindow *arg1 = (wxWindow *) 0 ;
29997 wxString *arg2 = 0 ;
29998 void *argp1 = 0 ;
29999 int res1 = 0 ;
30000 bool temp2 = false ;
30001 PyObject * obj0 = 0 ;
30002 PyObject * obj1 = 0 ;
30003 char * kwnames[] = {
30004 (char *) "self",(char *) "name", NULL
30005 };
30006
30007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30009 if (!SWIG_IsOK(res1)) {
30010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30011 }
30012 arg1 = reinterpret_cast< wxWindow * >(argp1);
30013 {
30014 arg2 = wxString_in_helper(obj1);
30015 if (arg2 == NULL) SWIG_fail;
30016 temp2 = true;
30017 }
30018 {
30019 PyThreadState* __tstate = wxPyBeginAllowThreads();
30020 (arg1)->SetName((wxString const &)*arg2);
30021 wxPyEndAllowThreads(__tstate);
30022 if (PyErr_Occurred()) SWIG_fail;
30023 }
30024 resultobj = SWIG_Py_Void();
30025 {
30026 if (temp2)
30027 delete arg2;
30028 }
30029 return resultobj;
30030 fail:
30031 {
30032 if (temp2)
30033 delete arg2;
30034 }
30035 return NULL;
30036 }
30037
30038
30039 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30040 PyObject *resultobj = 0;
30041 wxWindow *arg1 = (wxWindow *) 0 ;
30042 wxString result;
30043 void *argp1 = 0 ;
30044 int res1 = 0 ;
30045 PyObject *swig_obj[1] ;
30046
30047 if (!args) SWIG_fail;
30048 swig_obj[0] = args;
30049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30050 if (!SWIG_IsOK(res1)) {
30051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30052 }
30053 arg1 = reinterpret_cast< wxWindow * >(argp1);
30054 {
30055 PyThreadState* __tstate = wxPyBeginAllowThreads();
30056 result = ((wxWindow const *)arg1)->GetName();
30057 wxPyEndAllowThreads(__tstate);
30058 if (PyErr_Occurred()) SWIG_fail;
30059 }
30060 {
30061 #if wxUSE_UNICODE
30062 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30063 #else
30064 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30065 #endif
30066 }
30067 return resultobj;
30068 fail:
30069 return NULL;
30070 }
30071
30072
30073 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30074 PyObject *resultobj = 0;
30075 wxWindow *arg1 = (wxWindow *) 0 ;
30076 wxWindowVariant arg2 ;
30077 void *argp1 = 0 ;
30078 int res1 = 0 ;
30079 int val2 ;
30080 int ecode2 = 0 ;
30081 PyObject * obj0 = 0 ;
30082 PyObject * obj1 = 0 ;
30083 char * kwnames[] = {
30084 (char *) "self",(char *) "variant", NULL
30085 };
30086
30087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30089 if (!SWIG_IsOK(res1)) {
30090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30091 }
30092 arg1 = reinterpret_cast< wxWindow * >(argp1);
30093 ecode2 = SWIG_AsVal_int(obj1, &val2);
30094 if (!SWIG_IsOK(ecode2)) {
30095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30096 }
30097 arg2 = static_cast< wxWindowVariant >(val2);
30098 {
30099 PyThreadState* __tstate = wxPyBeginAllowThreads();
30100 (arg1)->SetWindowVariant(arg2);
30101 wxPyEndAllowThreads(__tstate);
30102 if (PyErr_Occurred()) SWIG_fail;
30103 }
30104 resultobj = SWIG_Py_Void();
30105 return resultobj;
30106 fail:
30107 return NULL;
30108 }
30109
30110
30111 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30112 PyObject *resultobj = 0;
30113 wxWindow *arg1 = (wxWindow *) 0 ;
30114 wxWindowVariant result;
30115 void *argp1 = 0 ;
30116 int res1 = 0 ;
30117 PyObject *swig_obj[1] ;
30118
30119 if (!args) SWIG_fail;
30120 swig_obj[0] = args;
30121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30122 if (!SWIG_IsOK(res1)) {
30123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30124 }
30125 arg1 = reinterpret_cast< wxWindow * >(argp1);
30126 {
30127 PyThreadState* __tstate = wxPyBeginAllowThreads();
30128 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30129 wxPyEndAllowThreads(__tstate);
30130 if (PyErr_Occurred()) SWIG_fail;
30131 }
30132 resultobj = SWIG_From_int(static_cast< int >(result));
30133 return resultobj;
30134 fail:
30135 return NULL;
30136 }
30137
30138
30139 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30140 PyObject *resultobj = 0;
30141 wxWindow *arg1 = (wxWindow *) 0 ;
30142 int arg2 ;
30143 void *argp1 = 0 ;
30144 int res1 = 0 ;
30145 int val2 ;
30146 int ecode2 = 0 ;
30147 PyObject * obj0 = 0 ;
30148 PyObject * obj1 = 0 ;
30149 char * kwnames[] = {
30150 (char *) "self",(char *) "winid", NULL
30151 };
30152
30153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30155 if (!SWIG_IsOK(res1)) {
30156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30157 }
30158 arg1 = reinterpret_cast< wxWindow * >(argp1);
30159 ecode2 = SWIG_AsVal_int(obj1, &val2);
30160 if (!SWIG_IsOK(ecode2)) {
30161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30162 }
30163 arg2 = static_cast< int >(val2);
30164 {
30165 PyThreadState* __tstate = wxPyBeginAllowThreads();
30166 (arg1)->SetId(arg2);
30167 wxPyEndAllowThreads(__tstate);
30168 if (PyErr_Occurred()) SWIG_fail;
30169 }
30170 resultobj = SWIG_Py_Void();
30171 return resultobj;
30172 fail:
30173 return NULL;
30174 }
30175
30176
30177 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30178 PyObject *resultobj = 0;
30179 wxWindow *arg1 = (wxWindow *) 0 ;
30180 int result;
30181 void *argp1 = 0 ;
30182 int res1 = 0 ;
30183 PyObject *swig_obj[1] ;
30184
30185 if (!args) SWIG_fail;
30186 swig_obj[0] = args;
30187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30188 if (!SWIG_IsOK(res1)) {
30189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30190 }
30191 arg1 = reinterpret_cast< wxWindow * >(argp1);
30192 {
30193 PyThreadState* __tstate = wxPyBeginAllowThreads();
30194 result = (int)((wxWindow const *)arg1)->GetId();
30195 wxPyEndAllowThreads(__tstate);
30196 if (PyErr_Occurred()) SWIG_fail;
30197 }
30198 resultobj = SWIG_From_int(static_cast< int >(result));
30199 return resultobj;
30200 fail:
30201 return NULL;
30202 }
30203
30204
30205 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30206 PyObject *resultobj = 0;
30207 int result;
30208
30209 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30210 {
30211 PyThreadState* __tstate = wxPyBeginAllowThreads();
30212 result = (int)wxWindow::NewControlId();
30213 wxPyEndAllowThreads(__tstate);
30214 if (PyErr_Occurred()) SWIG_fail;
30215 }
30216 resultobj = SWIG_From_int(static_cast< int >(result));
30217 return resultobj;
30218 fail:
30219 return NULL;
30220 }
30221
30222
30223 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30224 PyObject *resultobj = 0;
30225 int arg1 ;
30226 int result;
30227 int val1 ;
30228 int ecode1 = 0 ;
30229 PyObject * obj0 = 0 ;
30230 char * kwnames[] = {
30231 (char *) "winid", NULL
30232 };
30233
30234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30235 ecode1 = SWIG_AsVal_int(obj0, &val1);
30236 if (!SWIG_IsOK(ecode1)) {
30237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30238 }
30239 arg1 = static_cast< int >(val1);
30240 {
30241 PyThreadState* __tstate = wxPyBeginAllowThreads();
30242 result = (int)wxWindow::NextControlId(arg1);
30243 wxPyEndAllowThreads(__tstate);
30244 if (PyErr_Occurred()) SWIG_fail;
30245 }
30246 resultobj = SWIG_From_int(static_cast< int >(result));
30247 return resultobj;
30248 fail:
30249 return NULL;
30250 }
30251
30252
30253 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30254 PyObject *resultobj = 0;
30255 int arg1 ;
30256 int result;
30257 int val1 ;
30258 int ecode1 = 0 ;
30259 PyObject * obj0 = 0 ;
30260 char * kwnames[] = {
30261 (char *) "winid", NULL
30262 };
30263
30264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30265 ecode1 = SWIG_AsVal_int(obj0, &val1);
30266 if (!SWIG_IsOK(ecode1)) {
30267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30268 }
30269 arg1 = static_cast< int >(val1);
30270 {
30271 PyThreadState* __tstate = wxPyBeginAllowThreads();
30272 result = (int)wxWindow::PrevControlId(arg1);
30273 wxPyEndAllowThreads(__tstate);
30274 if (PyErr_Occurred()) SWIG_fail;
30275 }
30276 resultobj = SWIG_From_int(static_cast< int >(result));
30277 return resultobj;
30278 fail:
30279 return NULL;
30280 }
30281
30282
30283 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30284 PyObject *resultobj = 0;
30285 wxWindow *arg1 = (wxWindow *) 0 ;
30286 wxSize *arg2 = 0 ;
30287 void *argp1 = 0 ;
30288 int res1 = 0 ;
30289 wxSize temp2 ;
30290 PyObject * obj0 = 0 ;
30291 PyObject * obj1 = 0 ;
30292 char * kwnames[] = {
30293 (char *) "self",(char *) "size", NULL
30294 };
30295
30296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30298 if (!SWIG_IsOK(res1)) {
30299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30300 }
30301 arg1 = reinterpret_cast< wxWindow * >(argp1);
30302 {
30303 arg2 = &temp2;
30304 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30305 }
30306 {
30307 PyThreadState* __tstate = wxPyBeginAllowThreads();
30308 (arg1)->SetSize((wxSize const &)*arg2);
30309 wxPyEndAllowThreads(__tstate);
30310 if (PyErr_Occurred()) SWIG_fail;
30311 }
30312 resultobj = SWIG_Py_Void();
30313 return resultobj;
30314 fail:
30315 return NULL;
30316 }
30317
30318
30319 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30320 PyObject *resultobj = 0;
30321 wxWindow *arg1 = (wxWindow *) 0 ;
30322 int arg2 ;
30323 int arg3 ;
30324 int arg4 ;
30325 int arg5 ;
30326 int arg6 = (int) wxSIZE_AUTO ;
30327 void *argp1 = 0 ;
30328 int res1 = 0 ;
30329 int val2 ;
30330 int ecode2 = 0 ;
30331 int val3 ;
30332 int ecode3 = 0 ;
30333 int val4 ;
30334 int ecode4 = 0 ;
30335 int val5 ;
30336 int ecode5 = 0 ;
30337 int val6 ;
30338 int ecode6 = 0 ;
30339 PyObject * obj0 = 0 ;
30340 PyObject * obj1 = 0 ;
30341 PyObject * obj2 = 0 ;
30342 PyObject * obj3 = 0 ;
30343 PyObject * obj4 = 0 ;
30344 PyObject * obj5 = 0 ;
30345 char * kwnames[] = {
30346 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30347 };
30348
30349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30351 if (!SWIG_IsOK(res1)) {
30352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30353 }
30354 arg1 = reinterpret_cast< wxWindow * >(argp1);
30355 ecode2 = SWIG_AsVal_int(obj1, &val2);
30356 if (!SWIG_IsOK(ecode2)) {
30357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30358 }
30359 arg2 = static_cast< int >(val2);
30360 ecode3 = SWIG_AsVal_int(obj2, &val3);
30361 if (!SWIG_IsOK(ecode3)) {
30362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30363 }
30364 arg3 = static_cast< int >(val3);
30365 ecode4 = SWIG_AsVal_int(obj3, &val4);
30366 if (!SWIG_IsOK(ecode4)) {
30367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30368 }
30369 arg4 = static_cast< int >(val4);
30370 ecode5 = SWIG_AsVal_int(obj4, &val5);
30371 if (!SWIG_IsOK(ecode5)) {
30372 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30373 }
30374 arg5 = static_cast< int >(val5);
30375 if (obj5) {
30376 ecode6 = SWIG_AsVal_int(obj5, &val6);
30377 if (!SWIG_IsOK(ecode6)) {
30378 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30379 }
30380 arg6 = static_cast< int >(val6);
30381 }
30382 {
30383 PyThreadState* __tstate = wxPyBeginAllowThreads();
30384 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30385 wxPyEndAllowThreads(__tstate);
30386 if (PyErr_Occurred()) SWIG_fail;
30387 }
30388 resultobj = SWIG_Py_Void();
30389 return resultobj;
30390 fail:
30391 return NULL;
30392 }
30393
30394
30395 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30396 PyObject *resultobj = 0;
30397 wxWindow *arg1 = (wxWindow *) 0 ;
30398 wxRect *arg2 = 0 ;
30399 int arg3 = (int) wxSIZE_AUTO ;
30400 void *argp1 = 0 ;
30401 int res1 = 0 ;
30402 wxRect temp2 ;
30403 int val3 ;
30404 int ecode3 = 0 ;
30405 PyObject * obj0 = 0 ;
30406 PyObject * obj1 = 0 ;
30407 PyObject * obj2 = 0 ;
30408 char * kwnames[] = {
30409 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30410 };
30411
30412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30414 if (!SWIG_IsOK(res1)) {
30415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30416 }
30417 arg1 = reinterpret_cast< wxWindow * >(argp1);
30418 {
30419 arg2 = &temp2;
30420 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30421 }
30422 if (obj2) {
30423 ecode3 = SWIG_AsVal_int(obj2, &val3);
30424 if (!SWIG_IsOK(ecode3)) {
30425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30426 }
30427 arg3 = static_cast< int >(val3);
30428 }
30429 {
30430 PyThreadState* __tstate = wxPyBeginAllowThreads();
30431 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30432 wxPyEndAllowThreads(__tstate);
30433 if (PyErr_Occurred()) SWIG_fail;
30434 }
30435 resultobj = SWIG_Py_Void();
30436 return resultobj;
30437 fail:
30438 return NULL;
30439 }
30440
30441
30442 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30443 PyObject *resultobj = 0;
30444 wxWindow *arg1 = (wxWindow *) 0 ;
30445 int arg2 ;
30446 int arg3 ;
30447 void *argp1 = 0 ;
30448 int res1 = 0 ;
30449 int val2 ;
30450 int ecode2 = 0 ;
30451 int val3 ;
30452 int ecode3 = 0 ;
30453 PyObject * obj0 = 0 ;
30454 PyObject * obj1 = 0 ;
30455 PyObject * obj2 = 0 ;
30456 char * kwnames[] = {
30457 (char *) "self",(char *) "width",(char *) "height", NULL
30458 };
30459
30460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30462 if (!SWIG_IsOK(res1)) {
30463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30464 }
30465 arg1 = reinterpret_cast< wxWindow * >(argp1);
30466 ecode2 = SWIG_AsVal_int(obj1, &val2);
30467 if (!SWIG_IsOK(ecode2)) {
30468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30469 }
30470 arg2 = static_cast< int >(val2);
30471 ecode3 = SWIG_AsVal_int(obj2, &val3);
30472 if (!SWIG_IsOK(ecode3)) {
30473 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30474 }
30475 arg3 = static_cast< int >(val3);
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 (arg1)->SetSize(arg2,arg3);
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 resultobj = SWIG_Py_Void();
30483 return resultobj;
30484 fail:
30485 return NULL;
30486 }
30487
30488
30489 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30490 PyObject *resultobj = 0;
30491 wxWindow *arg1 = (wxWindow *) 0 ;
30492 wxPoint *arg2 = 0 ;
30493 int arg3 = (int) wxSIZE_USE_EXISTING ;
30494 void *argp1 = 0 ;
30495 int res1 = 0 ;
30496 wxPoint temp2 ;
30497 int val3 ;
30498 int ecode3 = 0 ;
30499 PyObject * obj0 = 0 ;
30500 PyObject * obj1 = 0 ;
30501 PyObject * obj2 = 0 ;
30502 char * kwnames[] = {
30503 (char *) "self",(char *) "pt",(char *) "flags", NULL
30504 };
30505
30506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30508 if (!SWIG_IsOK(res1)) {
30509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30510 }
30511 arg1 = reinterpret_cast< wxWindow * >(argp1);
30512 {
30513 arg2 = &temp2;
30514 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30515 }
30516 if (obj2) {
30517 ecode3 = SWIG_AsVal_int(obj2, &val3);
30518 if (!SWIG_IsOK(ecode3)) {
30519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30520 }
30521 arg3 = static_cast< int >(val3);
30522 }
30523 {
30524 PyThreadState* __tstate = wxPyBeginAllowThreads();
30525 (arg1)->Move((wxPoint const &)*arg2,arg3);
30526 wxPyEndAllowThreads(__tstate);
30527 if (PyErr_Occurred()) SWIG_fail;
30528 }
30529 resultobj = SWIG_Py_Void();
30530 return resultobj;
30531 fail:
30532 return NULL;
30533 }
30534
30535
30536 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30537 PyObject *resultobj = 0;
30538 wxWindow *arg1 = (wxWindow *) 0 ;
30539 int arg2 ;
30540 int arg3 ;
30541 int arg4 = (int) wxSIZE_USE_EXISTING ;
30542 void *argp1 = 0 ;
30543 int res1 = 0 ;
30544 int val2 ;
30545 int ecode2 = 0 ;
30546 int val3 ;
30547 int ecode3 = 0 ;
30548 int val4 ;
30549 int ecode4 = 0 ;
30550 PyObject * obj0 = 0 ;
30551 PyObject * obj1 = 0 ;
30552 PyObject * obj2 = 0 ;
30553 PyObject * obj3 = 0 ;
30554 char * kwnames[] = {
30555 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30556 };
30557
30558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30560 if (!SWIG_IsOK(res1)) {
30561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30562 }
30563 arg1 = reinterpret_cast< wxWindow * >(argp1);
30564 ecode2 = SWIG_AsVal_int(obj1, &val2);
30565 if (!SWIG_IsOK(ecode2)) {
30566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30567 }
30568 arg2 = static_cast< int >(val2);
30569 ecode3 = SWIG_AsVal_int(obj2, &val3);
30570 if (!SWIG_IsOK(ecode3)) {
30571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30572 }
30573 arg3 = static_cast< int >(val3);
30574 if (obj3) {
30575 ecode4 = SWIG_AsVal_int(obj3, &val4);
30576 if (!SWIG_IsOK(ecode4)) {
30577 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30578 }
30579 arg4 = static_cast< int >(val4);
30580 }
30581 {
30582 PyThreadState* __tstate = wxPyBeginAllowThreads();
30583 (arg1)->Move(arg2,arg3,arg4);
30584 wxPyEndAllowThreads(__tstate);
30585 if (PyErr_Occurred()) SWIG_fail;
30586 }
30587 resultobj = SWIG_Py_Void();
30588 return resultobj;
30589 fail:
30590 return NULL;
30591 }
30592
30593
30594 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30595 PyObject *resultobj = 0;
30596 wxWindow *arg1 = (wxWindow *) 0 ;
30597 wxSize const &arg2_defvalue = wxDefaultSize ;
30598 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30599 void *argp1 = 0 ;
30600 int res1 = 0 ;
30601 wxSize temp2 ;
30602 PyObject * obj0 = 0 ;
30603 PyObject * obj1 = 0 ;
30604 char * kwnames[] = {
30605 (char *) "self",(char *) "size", NULL
30606 };
30607
30608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30610 if (!SWIG_IsOK(res1)) {
30611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30612 }
30613 arg1 = reinterpret_cast< wxWindow * >(argp1);
30614 if (obj1) {
30615 {
30616 arg2 = &temp2;
30617 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30618 }
30619 }
30620 {
30621 PyThreadState* __tstate = wxPyBeginAllowThreads();
30622 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30623 wxPyEndAllowThreads(__tstate);
30624 if (PyErr_Occurred()) SWIG_fail;
30625 }
30626 resultobj = SWIG_Py_Void();
30627 return resultobj;
30628 fail:
30629 return NULL;
30630 }
30631
30632
30633 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30634 PyObject *resultobj = 0;
30635 wxWindow *arg1 = (wxWindow *) 0 ;
30636 void *argp1 = 0 ;
30637 int res1 = 0 ;
30638 PyObject *swig_obj[1] ;
30639
30640 if (!args) SWIG_fail;
30641 swig_obj[0] = args;
30642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30643 if (!SWIG_IsOK(res1)) {
30644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30645 }
30646 arg1 = reinterpret_cast< wxWindow * >(argp1);
30647 {
30648 PyThreadState* __tstate = wxPyBeginAllowThreads();
30649 (arg1)->Raise();
30650 wxPyEndAllowThreads(__tstate);
30651 if (PyErr_Occurred()) SWIG_fail;
30652 }
30653 resultobj = SWIG_Py_Void();
30654 return resultobj;
30655 fail:
30656 return NULL;
30657 }
30658
30659
30660 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30661 PyObject *resultobj = 0;
30662 wxWindow *arg1 = (wxWindow *) 0 ;
30663 void *argp1 = 0 ;
30664 int res1 = 0 ;
30665 PyObject *swig_obj[1] ;
30666
30667 if (!args) SWIG_fail;
30668 swig_obj[0] = args;
30669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30670 if (!SWIG_IsOK(res1)) {
30671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30672 }
30673 arg1 = reinterpret_cast< wxWindow * >(argp1);
30674 {
30675 PyThreadState* __tstate = wxPyBeginAllowThreads();
30676 (arg1)->Lower();
30677 wxPyEndAllowThreads(__tstate);
30678 if (PyErr_Occurred()) SWIG_fail;
30679 }
30680 resultobj = SWIG_Py_Void();
30681 return resultobj;
30682 fail:
30683 return NULL;
30684 }
30685
30686
30687 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30688 PyObject *resultobj = 0;
30689 wxWindow *arg1 = (wxWindow *) 0 ;
30690 wxSize *arg2 = 0 ;
30691 void *argp1 = 0 ;
30692 int res1 = 0 ;
30693 wxSize temp2 ;
30694 PyObject * obj0 = 0 ;
30695 PyObject * obj1 = 0 ;
30696 char * kwnames[] = {
30697 (char *) "self",(char *) "size", NULL
30698 };
30699
30700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30702 if (!SWIG_IsOK(res1)) {
30703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30704 }
30705 arg1 = reinterpret_cast< wxWindow * >(argp1);
30706 {
30707 arg2 = &temp2;
30708 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30709 }
30710 {
30711 PyThreadState* __tstate = wxPyBeginAllowThreads();
30712 (arg1)->SetClientSize((wxSize const &)*arg2);
30713 wxPyEndAllowThreads(__tstate);
30714 if (PyErr_Occurred()) SWIG_fail;
30715 }
30716 resultobj = SWIG_Py_Void();
30717 return resultobj;
30718 fail:
30719 return NULL;
30720 }
30721
30722
30723 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30724 PyObject *resultobj = 0;
30725 wxWindow *arg1 = (wxWindow *) 0 ;
30726 int arg2 ;
30727 int arg3 ;
30728 void *argp1 = 0 ;
30729 int res1 = 0 ;
30730 int val2 ;
30731 int ecode2 = 0 ;
30732 int val3 ;
30733 int ecode3 = 0 ;
30734 PyObject * obj0 = 0 ;
30735 PyObject * obj1 = 0 ;
30736 PyObject * obj2 = 0 ;
30737 char * kwnames[] = {
30738 (char *) "self",(char *) "width",(char *) "height", NULL
30739 };
30740
30741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30743 if (!SWIG_IsOK(res1)) {
30744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30745 }
30746 arg1 = reinterpret_cast< wxWindow * >(argp1);
30747 ecode2 = SWIG_AsVal_int(obj1, &val2);
30748 if (!SWIG_IsOK(ecode2)) {
30749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30750 }
30751 arg2 = static_cast< int >(val2);
30752 ecode3 = SWIG_AsVal_int(obj2, &val3);
30753 if (!SWIG_IsOK(ecode3)) {
30754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30755 }
30756 arg3 = static_cast< int >(val3);
30757 {
30758 PyThreadState* __tstate = wxPyBeginAllowThreads();
30759 (arg1)->SetClientSize(arg2,arg3);
30760 wxPyEndAllowThreads(__tstate);
30761 if (PyErr_Occurred()) SWIG_fail;
30762 }
30763 resultobj = SWIG_Py_Void();
30764 return resultobj;
30765 fail:
30766 return NULL;
30767 }
30768
30769
30770 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30771 PyObject *resultobj = 0;
30772 wxWindow *arg1 = (wxWindow *) 0 ;
30773 wxRect *arg2 = 0 ;
30774 void *argp1 = 0 ;
30775 int res1 = 0 ;
30776 wxRect temp2 ;
30777 PyObject * obj0 = 0 ;
30778 PyObject * obj1 = 0 ;
30779 char * kwnames[] = {
30780 (char *) "self",(char *) "rect", NULL
30781 };
30782
30783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30785 if (!SWIG_IsOK(res1)) {
30786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30787 }
30788 arg1 = reinterpret_cast< wxWindow * >(argp1);
30789 {
30790 arg2 = &temp2;
30791 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30792 }
30793 {
30794 PyThreadState* __tstate = wxPyBeginAllowThreads();
30795 (arg1)->SetClientSize((wxRect const &)*arg2);
30796 wxPyEndAllowThreads(__tstate);
30797 if (PyErr_Occurred()) SWIG_fail;
30798 }
30799 resultobj = SWIG_Py_Void();
30800 return resultobj;
30801 fail:
30802 return NULL;
30803 }
30804
30805
30806 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30807 PyObject *resultobj = 0;
30808 wxWindow *arg1 = (wxWindow *) 0 ;
30809 wxPoint result;
30810 void *argp1 = 0 ;
30811 int res1 = 0 ;
30812 PyObject *swig_obj[1] ;
30813
30814 if (!args) SWIG_fail;
30815 swig_obj[0] = args;
30816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30817 if (!SWIG_IsOK(res1)) {
30818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30819 }
30820 arg1 = reinterpret_cast< wxWindow * >(argp1);
30821 {
30822 PyThreadState* __tstate = wxPyBeginAllowThreads();
30823 result = ((wxWindow const *)arg1)->GetPosition();
30824 wxPyEndAllowThreads(__tstate);
30825 if (PyErr_Occurred()) SWIG_fail;
30826 }
30827 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30828 return resultobj;
30829 fail:
30830 return NULL;
30831 }
30832
30833
30834 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30835 PyObject *resultobj = 0;
30836 wxWindow *arg1 = (wxWindow *) 0 ;
30837 int *arg2 = (int *) 0 ;
30838 int *arg3 = (int *) 0 ;
30839 void *argp1 = 0 ;
30840 int res1 = 0 ;
30841 int temp2 ;
30842 int res2 = SWIG_TMPOBJ ;
30843 int temp3 ;
30844 int res3 = SWIG_TMPOBJ ;
30845 PyObject *swig_obj[1] ;
30846
30847 arg2 = &temp2;
30848 arg3 = &temp3;
30849 if (!args) SWIG_fail;
30850 swig_obj[0] = args;
30851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30852 if (!SWIG_IsOK(res1)) {
30853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30854 }
30855 arg1 = reinterpret_cast< wxWindow * >(argp1);
30856 {
30857 PyThreadState* __tstate = wxPyBeginAllowThreads();
30858 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30859 wxPyEndAllowThreads(__tstate);
30860 if (PyErr_Occurred()) SWIG_fail;
30861 }
30862 resultobj = SWIG_Py_Void();
30863 if (SWIG_IsTmpObj(res2)) {
30864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30865 } else {
30866 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30868 }
30869 if (SWIG_IsTmpObj(res3)) {
30870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30871 } else {
30872 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30874 }
30875 return resultobj;
30876 fail:
30877 return NULL;
30878 }
30879
30880
30881 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30882 PyObject *resultobj = 0;
30883 wxWindow *arg1 = (wxWindow *) 0 ;
30884 wxPoint result;
30885 void *argp1 = 0 ;
30886 int res1 = 0 ;
30887 PyObject *swig_obj[1] ;
30888
30889 if (!args) SWIG_fail;
30890 swig_obj[0] = args;
30891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30892 if (!SWIG_IsOK(res1)) {
30893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30894 }
30895 arg1 = reinterpret_cast< wxWindow * >(argp1);
30896 {
30897 PyThreadState* __tstate = wxPyBeginAllowThreads();
30898 result = ((wxWindow const *)arg1)->GetScreenPosition();
30899 wxPyEndAllowThreads(__tstate);
30900 if (PyErr_Occurred()) SWIG_fail;
30901 }
30902 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30903 return resultobj;
30904 fail:
30905 return NULL;
30906 }
30907
30908
30909 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30910 PyObject *resultobj = 0;
30911 wxWindow *arg1 = (wxWindow *) 0 ;
30912 int *arg2 = (int *) 0 ;
30913 int *arg3 = (int *) 0 ;
30914 void *argp1 = 0 ;
30915 int res1 = 0 ;
30916 int temp2 ;
30917 int res2 = SWIG_TMPOBJ ;
30918 int temp3 ;
30919 int res3 = SWIG_TMPOBJ ;
30920 PyObject *swig_obj[1] ;
30921
30922 arg2 = &temp2;
30923 arg3 = &temp3;
30924 if (!args) SWIG_fail;
30925 swig_obj[0] = args;
30926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30927 if (!SWIG_IsOK(res1)) {
30928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30929 }
30930 arg1 = reinterpret_cast< wxWindow * >(argp1);
30931 {
30932 PyThreadState* __tstate = wxPyBeginAllowThreads();
30933 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30934 wxPyEndAllowThreads(__tstate);
30935 if (PyErr_Occurred()) SWIG_fail;
30936 }
30937 resultobj = SWIG_Py_Void();
30938 if (SWIG_IsTmpObj(res2)) {
30939 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30940 } else {
30941 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30943 }
30944 if (SWIG_IsTmpObj(res3)) {
30945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30946 } else {
30947 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30948 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30949 }
30950 return resultobj;
30951 fail:
30952 return NULL;
30953 }
30954
30955
30956 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30957 PyObject *resultobj = 0;
30958 wxWindow *arg1 = (wxWindow *) 0 ;
30959 wxRect result;
30960 void *argp1 = 0 ;
30961 int res1 = 0 ;
30962 PyObject *swig_obj[1] ;
30963
30964 if (!args) SWIG_fail;
30965 swig_obj[0] = args;
30966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30967 if (!SWIG_IsOK(res1)) {
30968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30969 }
30970 arg1 = reinterpret_cast< wxWindow * >(argp1);
30971 {
30972 PyThreadState* __tstate = wxPyBeginAllowThreads();
30973 result = ((wxWindow const *)arg1)->GetScreenRect();
30974 wxPyEndAllowThreads(__tstate);
30975 if (PyErr_Occurred()) SWIG_fail;
30976 }
30977 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30978 return resultobj;
30979 fail:
30980 return NULL;
30981 }
30982
30983
30984 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30985 PyObject *resultobj = 0;
30986 wxWindow *arg1 = (wxWindow *) 0 ;
30987 wxSize result;
30988 void *argp1 = 0 ;
30989 int res1 = 0 ;
30990 PyObject *swig_obj[1] ;
30991
30992 if (!args) SWIG_fail;
30993 swig_obj[0] = args;
30994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30995 if (!SWIG_IsOK(res1)) {
30996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30997 }
30998 arg1 = reinterpret_cast< wxWindow * >(argp1);
30999 {
31000 PyThreadState* __tstate = wxPyBeginAllowThreads();
31001 result = ((wxWindow const *)arg1)->GetSize();
31002 wxPyEndAllowThreads(__tstate);
31003 if (PyErr_Occurred()) SWIG_fail;
31004 }
31005 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31006 return resultobj;
31007 fail:
31008 return NULL;
31009 }
31010
31011
31012 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31013 PyObject *resultobj = 0;
31014 wxWindow *arg1 = (wxWindow *) 0 ;
31015 int *arg2 = (int *) 0 ;
31016 int *arg3 = (int *) 0 ;
31017 void *argp1 = 0 ;
31018 int res1 = 0 ;
31019 int temp2 ;
31020 int res2 = SWIG_TMPOBJ ;
31021 int temp3 ;
31022 int res3 = SWIG_TMPOBJ ;
31023 PyObject *swig_obj[1] ;
31024
31025 arg2 = &temp2;
31026 arg3 = &temp3;
31027 if (!args) SWIG_fail;
31028 swig_obj[0] = args;
31029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31030 if (!SWIG_IsOK(res1)) {
31031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31032 }
31033 arg1 = reinterpret_cast< wxWindow * >(argp1);
31034 {
31035 PyThreadState* __tstate = wxPyBeginAllowThreads();
31036 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31037 wxPyEndAllowThreads(__tstate);
31038 if (PyErr_Occurred()) SWIG_fail;
31039 }
31040 resultobj = SWIG_Py_Void();
31041 if (SWIG_IsTmpObj(res2)) {
31042 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31043 } else {
31044 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31046 }
31047 if (SWIG_IsTmpObj(res3)) {
31048 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31049 } else {
31050 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31051 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31052 }
31053 return resultobj;
31054 fail:
31055 return NULL;
31056 }
31057
31058
31059 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31060 PyObject *resultobj = 0;
31061 wxWindow *arg1 = (wxWindow *) 0 ;
31062 wxRect result;
31063 void *argp1 = 0 ;
31064 int res1 = 0 ;
31065 PyObject *swig_obj[1] ;
31066
31067 if (!args) SWIG_fail;
31068 swig_obj[0] = args;
31069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31070 if (!SWIG_IsOK(res1)) {
31071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31072 }
31073 arg1 = reinterpret_cast< wxWindow * >(argp1);
31074 {
31075 PyThreadState* __tstate = wxPyBeginAllowThreads();
31076 result = ((wxWindow const *)arg1)->GetRect();
31077 wxPyEndAllowThreads(__tstate);
31078 if (PyErr_Occurred()) SWIG_fail;
31079 }
31080 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31081 return resultobj;
31082 fail:
31083 return NULL;
31084 }
31085
31086
31087 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31088 PyObject *resultobj = 0;
31089 wxWindow *arg1 = (wxWindow *) 0 ;
31090 wxSize result;
31091 void *argp1 = 0 ;
31092 int res1 = 0 ;
31093 PyObject *swig_obj[1] ;
31094
31095 if (!args) SWIG_fail;
31096 swig_obj[0] = args;
31097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31098 if (!SWIG_IsOK(res1)) {
31099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31100 }
31101 arg1 = reinterpret_cast< wxWindow * >(argp1);
31102 {
31103 PyThreadState* __tstate = wxPyBeginAllowThreads();
31104 result = ((wxWindow const *)arg1)->GetClientSize();
31105 wxPyEndAllowThreads(__tstate);
31106 if (PyErr_Occurred()) SWIG_fail;
31107 }
31108 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31109 return resultobj;
31110 fail:
31111 return NULL;
31112 }
31113
31114
31115 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31116 PyObject *resultobj = 0;
31117 wxWindow *arg1 = (wxWindow *) 0 ;
31118 int *arg2 = (int *) 0 ;
31119 int *arg3 = (int *) 0 ;
31120 void *argp1 = 0 ;
31121 int res1 = 0 ;
31122 int temp2 ;
31123 int res2 = SWIG_TMPOBJ ;
31124 int temp3 ;
31125 int res3 = SWIG_TMPOBJ ;
31126 PyObject *swig_obj[1] ;
31127
31128 arg2 = &temp2;
31129 arg3 = &temp3;
31130 if (!args) SWIG_fail;
31131 swig_obj[0] = args;
31132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31133 if (!SWIG_IsOK(res1)) {
31134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31135 }
31136 arg1 = reinterpret_cast< wxWindow * >(argp1);
31137 {
31138 PyThreadState* __tstate = wxPyBeginAllowThreads();
31139 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31140 wxPyEndAllowThreads(__tstate);
31141 if (PyErr_Occurred()) SWIG_fail;
31142 }
31143 resultobj = SWIG_Py_Void();
31144 if (SWIG_IsTmpObj(res2)) {
31145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31146 } else {
31147 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31149 }
31150 if (SWIG_IsTmpObj(res3)) {
31151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31152 } else {
31153 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31154 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31155 }
31156 return resultobj;
31157 fail:
31158 return NULL;
31159 }
31160
31161
31162 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31163 PyObject *resultobj = 0;
31164 wxWindow *arg1 = (wxWindow *) 0 ;
31165 wxPoint 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_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31175 }
31176 arg1 = reinterpret_cast< wxWindow * >(argp1);
31177 {
31178 PyThreadState* __tstate = wxPyBeginAllowThreads();
31179 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31180 wxPyEndAllowThreads(__tstate);
31181 if (PyErr_Occurred()) SWIG_fail;
31182 }
31183 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31184 return resultobj;
31185 fail:
31186 return NULL;
31187 }
31188
31189
31190 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31191 PyObject *resultobj = 0;
31192 wxWindow *arg1 = (wxWindow *) 0 ;
31193 wxRect result;
31194 void *argp1 = 0 ;
31195 int res1 = 0 ;
31196 PyObject *swig_obj[1] ;
31197
31198 if (!args) SWIG_fail;
31199 swig_obj[0] = args;
31200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31201 if (!SWIG_IsOK(res1)) {
31202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31203 }
31204 arg1 = reinterpret_cast< wxWindow * >(argp1);
31205 {
31206 PyThreadState* __tstate = wxPyBeginAllowThreads();
31207 result = ((wxWindow const *)arg1)->GetClientRect();
31208 wxPyEndAllowThreads(__tstate);
31209 if (PyErr_Occurred()) SWIG_fail;
31210 }
31211 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31212 return resultobj;
31213 fail:
31214 return NULL;
31215 }
31216
31217
31218 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31219 PyObject *resultobj = 0;
31220 wxWindow *arg1 = (wxWindow *) 0 ;
31221 wxSize result;
31222 void *argp1 = 0 ;
31223 int res1 = 0 ;
31224 PyObject *swig_obj[1] ;
31225
31226 if (!args) SWIG_fail;
31227 swig_obj[0] = args;
31228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31229 if (!SWIG_IsOK(res1)) {
31230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31231 }
31232 arg1 = reinterpret_cast< wxWindow * >(argp1);
31233 {
31234 PyThreadState* __tstate = wxPyBeginAllowThreads();
31235 result = ((wxWindow const *)arg1)->GetBestSize();
31236 wxPyEndAllowThreads(__tstate);
31237 if (PyErr_Occurred()) SWIG_fail;
31238 }
31239 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31240 return resultobj;
31241 fail:
31242 return NULL;
31243 }
31244
31245
31246 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31247 PyObject *resultobj = 0;
31248 wxWindow *arg1 = (wxWindow *) 0 ;
31249 int *arg2 = (int *) 0 ;
31250 int *arg3 = (int *) 0 ;
31251 void *argp1 = 0 ;
31252 int res1 = 0 ;
31253 int temp2 ;
31254 int res2 = SWIG_TMPOBJ ;
31255 int temp3 ;
31256 int res3 = SWIG_TMPOBJ ;
31257 PyObject *swig_obj[1] ;
31258
31259 arg2 = &temp2;
31260 arg3 = &temp3;
31261 if (!args) SWIG_fail;
31262 swig_obj[0] = args;
31263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31264 if (!SWIG_IsOK(res1)) {
31265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31266 }
31267 arg1 = reinterpret_cast< wxWindow * >(argp1);
31268 {
31269 PyThreadState* __tstate = wxPyBeginAllowThreads();
31270 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31271 wxPyEndAllowThreads(__tstate);
31272 if (PyErr_Occurred()) SWIG_fail;
31273 }
31274 resultobj = SWIG_Py_Void();
31275 if (SWIG_IsTmpObj(res2)) {
31276 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31277 } else {
31278 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31279 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31280 }
31281 if (SWIG_IsTmpObj(res3)) {
31282 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31283 } else {
31284 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31286 }
31287 return resultobj;
31288 fail:
31289 return NULL;
31290 }
31291
31292
31293 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31294 PyObject *resultobj = 0;
31295 wxWindow *arg1 = (wxWindow *) 0 ;
31296 void *argp1 = 0 ;
31297 int res1 = 0 ;
31298 PyObject *swig_obj[1] ;
31299
31300 if (!args) SWIG_fail;
31301 swig_obj[0] = args;
31302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31303 if (!SWIG_IsOK(res1)) {
31304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31305 }
31306 arg1 = reinterpret_cast< wxWindow * >(argp1);
31307 {
31308 PyThreadState* __tstate = wxPyBeginAllowThreads();
31309 (arg1)->InvalidateBestSize();
31310 wxPyEndAllowThreads(__tstate);
31311 if (PyErr_Occurred()) SWIG_fail;
31312 }
31313 resultobj = SWIG_Py_Void();
31314 return resultobj;
31315 fail:
31316 return NULL;
31317 }
31318
31319
31320 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31321 PyObject *resultobj = 0;
31322 wxWindow *arg1 = (wxWindow *) 0 ;
31323 wxSize *arg2 = 0 ;
31324 void *argp1 = 0 ;
31325 int res1 = 0 ;
31326 wxSize temp2 ;
31327 PyObject * obj0 = 0 ;
31328 PyObject * obj1 = 0 ;
31329 char * kwnames[] = {
31330 (char *) "self",(char *) "size", NULL
31331 };
31332
31333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31335 if (!SWIG_IsOK(res1)) {
31336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31337 }
31338 arg1 = reinterpret_cast< wxWindow * >(argp1);
31339 {
31340 arg2 = &temp2;
31341 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31342 }
31343 {
31344 PyThreadState* __tstate = wxPyBeginAllowThreads();
31345 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31346 wxPyEndAllowThreads(__tstate);
31347 if (PyErr_Occurred()) SWIG_fail;
31348 }
31349 resultobj = SWIG_Py_Void();
31350 return resultobj;
31351 fail:
31352 return NULL;
31353 }
31354
31355
31356 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31357 PyObject *resultobj = 0;
31358 wxWindow *arg1 = (wxWindow *) 0 ;
31359 wxSize result;
31360 void *argp1 = 0 ;
31361 int res1 = 0 ;
31362 PyObject *swig_obj[1] ;
31363
31364 if (!args) SWIG_fail;
31365 swig_obj[0] = args;
31366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31367 if (!SWIG_IsOK(res1)) {
31368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31369 }
31370 arg1 = reinterpret_cast< wxWindow * >(argp1);
31371 {
31372 PyThreadState* __tstate = wxPyBeginAllowThreads();
31373 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31374 wxPyEndAllowThreads(__tstate);
31375 if (PyErr_Occurred()) SWIG_fail;
31376 }
31377 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31378 return resultobj;
31379 fail:
31380 return NULL;
31381 }
31382
31383
31384 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31385 PyObject *resultobj = 0;
31386 wxWindow *arg1 = (wxWindow *) 0 ;
31387 wxSize result;
31388 void *argp1 = 0 ;
31389 int res1 = 0 ;
31390 PyObject *swig_obj[1] ;
31391
31392 if (!args) SWIG_fail;
31393 swig_obj[0] = args;
31394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31395 if (!SWIG_IsOK(res1)) {
31396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31397 }
31398 arg1 = reinterpret_cast< wxWindow * >(argp1);
31399 {
31400 PyThreadState* __tstate = wxPyBeginAllowThreads();
31401 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31402 wxPyEndAllowThreads(__tstate);
31403 if (PyErr_Occurred()) SWIG_fail;
31404 }
31405 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31406 return resultobj;
31407 fail:
31408 return NULL;
31409 }
31410
31411
31412 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31413 PyObject *resultobj = 0;
31414 wxWindow *arg1 = (wxWindow *) 0 ;
31415 int arg2 = (int) wxBOTH ;
31416 void *argp1 = 0 ;
31417 int res1 = 0 ;
31418 int val2 ;
31419 int ecode2 = 0 ;
31420 PyObject * obj0 = 0 ;
31421 PyObject * obj1 = 0 ;
31422 char * kwnames[] = {
31423 (char *) "self",(char *) "direction", NULL
31424 };
31425
31426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31428 if (!SWIG_IsOK(res1)) {
31429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31430 }
31431 arg1 = reinterpret_cast< wxWindow * >(argp1);
31432 if (obj1) {
31433 ecode2 = SWIG_AsVal_int(obj1, &val2);
31434 if (!SWIG_IsOK(ecode2)) {
31435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31436 }
31437 arg2 = static_cast< int >(val2);
31438 }
31439 {
31440 PyThreadState* __tstate = wxPyBeginAllowThreads();
31441 (arg1)->Center(arg2);
31442 wxPyEndAllowThreads(__tstate);
31443 if (PyErr_Occurred()) SWIG_fail;
31444 }
31445 resultobj = SWIG_Py_Void();
31446 return resultobj;
31447 fail:
31448 return NULL;
31449 }
31450
31451
31452 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31453 PyObject *resultobj = 0;
31454 wxWindow *arg1 = (wxWindow *) 0 ;
31455 int arg2 = (int) wxBOTH ;
31456 void *argp1 = 0 ;
31457 int res1 = 0 ;
31458 int val2 ;
31459 int ecode2 = 0 ;
31460 PyObject * obj0 = 0 ;
31461 PyObject * obj1 = 0 ;
31462 char * kwnames[] = {
31463 (char *) "self",(char *) "dir", NULL
31464 };
31465
31466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31468 if (!SWIG_IsOK(res1)) {
31469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31470 }
31471 arg1 = reinterpret_cast< wxWindow * >(argp1);
31472 if (obj1) {
31473 ecode2 = SWIG_AsVal_int(obj1, &val2);
31474 if (!SWIG_IsOK(ecode2)) {
31475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31476 }
31477 arg2 = static_cast< int >(val2);
31478 }
31479 {
31480 PyThreadState* __tstate = wxPyBeginAllowThreads();
31481 (arg1)->CenterOnParent(arg2);
31482 wxPyEndAllowThreads(__tstate);
31483 if (PyErr_Occurred()) SWIG_fail;
31484 }
31485 resultobj = SWIG_Py_Void();
31486 return resultobj;
31487 fail:
31488 return NULL;
31489 }
31490
31491
31492 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31493 PyObject *resultobj = 0;
31494 wxWindow *arg1 = (wxWindow *) 0 ;
31495 void *argp1 = 0 ;
31496 int res1 = 0 ;
31497 PyObject *swig_obj[1] ;
31498
31499 if (!args) SWIG_fail;
31500 swig_obj[0] = args;
31501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31502 if (!SWIG_IsOK(res1)) {
31503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31504 }
31505 arg1 = reinterpret_cast< wxWindow * >(argp1);
31506 {
31507 PyThreadState* __tstate = wxPyBeginAllowThreads();
31508 (arg1)->Fit();
31509 wxPyEndAllowThreads(__tstate);
31510 if (PyErr_Occurred()) SWIG_fail;
31511 }
31512 resultobj = SWIG_Py_Void();
31513 return resultobj;
31514 fail:
31515 return NULL;
31516 }
31517
31518
31519 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31520 PyObject *resultobj = 0;
31521 wxWindow *arg1 = (wxWindow *) 0 ;
31522 void *argp1 = 0 ;
31523 int res1 = 0 ;
31524 PyObject *swig_obj[1] ;
31525
31526 if (!args) SWIG_fail;
31527 swig_obj[0] = args;
31528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31529 if (!SWIG_IsOK(res1)) {
31530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31531 }
31532 arg1 = reinterpret_cast< wxWindow * >(argp1);
31533 {
31534 PyThreadState* __tstate = wxPyBeginAllowThreads();
31535 (arg1)->FitInside();
31536 wxPyEndAllowThreads(__tstate);
31537 if (PyErr_Occurred()) SWIG_fail;
31538 }
31539 resultobj = SWIG_Py_Void();
31540 return resultobj;
31541 fail:
31542 return NULL;
31543 }
31544
31545
31546 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31547 PyObject *resultobj = 0;
31548 wxWindow *arg1 = (wxWindow *) 0 ;
31549 int arg2 ;
31550 int arg3 ;
31551 int arg4 = (int) -1 ;
31552 int arg5 = (int) -1 ;
31553 int arg6 = (int) -1 ;
31554 int arg7 = (int) -1 ;
31555 void *argp1 = 0 ;
31556 int res1 = 0 ;
31557 int val2 ;
31558 int ecode2 = 0 ;
31559 int val3 ;
31560 int ecode3 = 0 ;
31561 int val4 ;
31562 int ecode4 = 0 ;
31563 int val5 ;
31564 int ecode5 = 0 ;
31565 int val6 ;
31566 int ecode6 = 0 ;
31567 int val7 ;
31568 int ecode7 = 0 ;
31569 PyObject * obj0 = 0 ;
31570 PyObject * obj1 = 0 ;
31571 PyObject * obj2 = 0 ;
31572 PyObject * obj3 = 0 ;
31573 PyObject * obj4 = 0 ;
31574 PyObject * obj5 = 0 ;
31575 PyObject * obj6 = 0 ;
31576 char * kwnames[] = {
31577 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31578 };
31579
31580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31582 if (!SWIG_IsOK(res1)) {
31583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31584 }
31585 arg1 = reinterpret_cast< wxWindow * >(argp1);
31586 ecode2 = SWIG_AsVal_int(obj1, &val2);
31587 if (!SWIG_IsOK(ecode2)) {
31588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31589 }
31590 arg2 = static_cast< int >(val2);
31591 ecode3 = SWIG_AsVal_int(obj2, &val3);
31592 if (!SWIG_IsOK(ecode3)) {
31593 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31594 }
31595 arg3 = static_cast< int >(val3);
31596 if (obj3) {
31597 ecode4 = SWIG_AsVal_int(obj3, &val4);
31598 if (!SWIG_IsOK(ecode4)) {
31599 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31600 }
31601 arg4 = static_cast< int >(val4);
31602 }
31603 if (obj4) {
31604 ecode5 = SWIG_AsVal_int(obj4, &val5);
31605 if (!SWIG_IsOK(ecode5)) {
31606 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31607 }
31608 arg5 = static_cast< int >(val5);
31609 }
31610 if (obj5) {
31611 ecode6 = SWIG_AsVal_int(obj5, &val6);
31612 if (!SWIG_IsOK(ecode6)) {
31613 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31614 }
31615 arg6 = static_cast< int >(val6);
31616 }
31617 if (obj6) {
31618 ecode7 = SWIG_AsVal_int(obj6, &val7);
31619 if (!SWIG_IsOK(ecode7)) {
31620 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31621 }
31622 arg7 = static_cast< int >(val7);
31623 }
31624 {
31625 PyThreadState* __tstate = wxPyBeginAllowThreads();
31626 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31627 wxPyEndAllowThreads(__tstate);
31628 if (PyErr_Occurred()) SWIG_fail;
31629 }
31630 resultobj = SWIG_Py_Void();
31631 return resultobj;
31632 fail:
31633 return NULL;
31634 }
31635
31636
31637 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31638 PyObject *resultobj = 0;
31639 wxWindow *arg1 = (wxWindow *) 0 ;
31640 wxSize *arg2 = 0 ;
31641 wxSize const &arg3_defvalue = wxDefaultSize ;
31642 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31643 wxSize const &arg4_defvalue = wxDefaultSize ;
31644 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31645 void *argp1 = 0 ;
31646 int res1 = 0 ;
31647 wxSize temp2 ;
31648 wxSize temp3 ;
31649 wxSize temp4 ;
31650 PyObject * obj0 = 0 ;
31651 PyObject * obj1 = 0 ;
31652 PyObject * obj2 = 0 ;
31653 PyObject * obj3 = 0 ;
31654 char * kwnames[] = {
31655 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31656 };
31657
31658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31660 if (!SWIG_IsOK(res1)) {
31661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31662 }
31663 arg1 = reinterpret_cast< wxWindow * >(argp1);
31664 {
31665 arg2 = &temp2;
31666 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31667 }
31668 if (obj2) {
31669 {
31670 arg3 = &temp3;
31671 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31672 }
31673 }
31674 if (obj3) {
31675 {
31676 arg4 = &temp4;
31677 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31678 }
31679 }
31680 {
31681 PyThreadState* __tstate = wxPyBeginAllowThreads();
31682 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31683 wxPyEndAllowThreads(__tstate);
31684 if (PyErr_Occurred()) SWIG_fail;
31685 }
31686 resultobj = SWIG_Py_Void();
31687 return resultobj;
31688 fail:
31689 return NULL;
31690 }
31691
31692
31693 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31694 PyObject *resultobj = 0;
31695 wxWindow *arg1 = (wxWindow *) 0 ;
31696 int arg2 ;
31697 int arg3 ;
31698 int arg4 = (int) -1 ;
31699 int arg5 = (int) -1 ;
31700 void *argp1 = 0 ;
31701 int res1 = 0 ;
31702 int val2 ;
31703 int ecode2 = 0 ;
31704 int val3 ;
31705 int ecode3 = 0 ;
31706 int val4 ;
31707 int ecode4 = 0 ;
31708 int val5 ;
31709 int ecode5 = 0 ;
31710 PyObject * obj0 = 0 ;
31711 PyObject * obj1 = 0 ;
31712 PyObject * obj2 = 0 ;
31713 PyObject * obj3 = 0 ;
31714 PyObject * obj4 = 0 ;
31715 char * kwnames[] = {
31716 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31717 };
31718
31719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31721 if (!SWIG_IsOK(res1)) {
31722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31723 }
31724 arg1 = reinterpret_cast< wxWindow * >(argp1);
31725 ecode2 = SWIG_AsVal_int(obj1, &val2);
31726 if (!SWIG_IsOK(ecode2)) {
31727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31728 }
31729 arg2 = static_cast< int >(val2);
31730 ecode3 = SWIG_AsVal_int(obj2, &val3);
31731 if (!SWIG_IsOK(ecode3)) {
31732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31733 }
31734 arg3 = static_cast< int >(val3);
31735 if (obj3) {
31736 ecode4 = SWIG_AsVal_int(obj3, &val4);
31737 if (!SWIG_IsOK(ecode4)) {
31738 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31739 }
31740 arg4 = static_cast< int >(val4);
31741 }
31742 if (obj4) {
31743 ecode5 = SWIG_AsVal_int(obj4, &val5);
31744 if (!SWIG_IsOK(ecode5)) {
31745 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31746 }
31747 arg5 = static_cast< int >(val5);
31748 }
31749 {
31750 PyThreadState* __tstate = wxPyBeginAllowThreads();
31751 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31752 wxPyEndAllowThreads(__tstate);
31753 if (PyErr_Occurred()) SWIG_fail;
31754 }
31755 resultobj = SWIG_Py_Void();
31756 return resultobj;
31757 fail:
31758 return NULL;
31759 }
31760
31761
31762 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31763 PyObject *resultobj = 0;
31764 wxWindow *arg1 = (wxWindow *) 0 ;
31765 wxSize *arg2 = 0 ;
31766 wxSize const &arg3_defvalue = wxDefaultSize ;
31767 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31768 void *argp1 = 0 ;
31769 int res1 = 0 ;
31770 wxSize temp2 ;
31771 wxSize temp3 ;
31772 PyObject * obj0 = 0 ;
31773 PyObject * obj1 = 0 ;
31774 PyObject * obj2 = 0 ;
31775 char * kwnames[] = {
31776 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31777 };
31778
31779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31781 if (!SWIG_IsOK(res1)) {
31782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31783 }
31784 arg1 = reinterpret_cast< wxWindow * >(argp1);
31785 {
31786 arg2 = &temp2;
31787 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31788 }
31789 if (obj2) {
31790 {
31791 arg3 = &temp3;
31792 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31793 }
31794 }
31795 {
31796 PyThreadState* __tstate = wxPyBeginAllowThreads();
31797 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
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_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31809 PyObject *resultobj = 0;
31810 wxWindow *arg1 = (wxWindow *) 0 ;
31811 wxSize 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_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31821 }
31822 arg1 = reinterpret_cast< wxWindow * >(argp1);
31823 {
31824 PyThreadState* __tstate = wxPyBeginAllowThreads();
31825 result = ((wxWindow const *)arg1)->GetMaxSize();
31826 wxPyEndAllowThreads(__tstate);
31827 if (PyErr_Occurred()) SWIG_fail;
31828 }
31829 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31830 return resultobj;
31831 fail:
31832 return NULL;
31833 }
31834
31835
31836 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31837 PyObject *resultobj = 0;
31838 wxWindow *arg1 = (wxWindow *) 0 ;
31839 wxSize result;
31840 void *argp1 = 0 ;
31841 int res1 = 0 ;
31842 PyObject *swig_obj[1] ;
31843
31844 if (!args) SWIG_fail;
31845 swig_obj[0] = args;
31846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31847 if (!SWIG_IsOK(res1)) {
31848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31849 }
31850 arg1 = reinterpret_cast< wxWindow * >(argp1);
31851 {
31852 PyThreadState* __tstate = wxPyBeginAllowThreads();
31853 result = ((wxWindow const *)arg1)->GetMinSize();
31854 wxPyEndAllowThreads(__tstate);
31855 if (PyErr_Occurred()) SWIG_fail;
31856 }
31857 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31858 return resultobj;
31859 fail:
31860 return NULL;
31861 }
31862
31863
31864 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31865 PyObject *resultobj = 0;
31866 wxWindow *arg1 = (wxWindow *) 0 ;
31867 wxSize *arg2 = 0 ;
31868 void *argp1 = 0 ;
31869 int res1 = 0 ;
31870 wxSize temp2 ;
31871 PyObject * obj0 = 0 ;
31872 PyObject * obj1 = 0 ;
31873 char * kwnames[] = {
31874 (char *) "self",(char *) "minSize", NULL
31875 };
31876
31877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31879 if (!SWIG_IsOK(res1)) {
31880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31881 }
31882 arg1 = reinterpret_cast< wxWindow * >(argp1);
31883 {
31884 arg2 = &temp2;
31885 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31886 }
31887 {
31888 PyThreadState* __tstate = wxPyBeginAllowThreads();
31889 (arg1)->SetMinSize((wxSize const &)*arg2);
31890 wxPyEndAllowThreads(__tstate);
31891 if (PyErr_Occurred()) SWIG_fail;
31892 }
31893 resultobj = SWIG_Py_Void();
31894 return resultobj;
31895 fail:
31896 return NULL;
31897 }
31898
31899
31900 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31901 PyObject *resultobj = 0;
31902 wxWindow *arg1 = (wxWindow *) 0 ;
31903 wxSize *arg2 = 0 ;
31904 void *argp1 = 0 ;
31905 int res1 = 0 ;
31906 wxSize temp2 ;
31907 PyObject * obj0 = 0 ;
31908 PyObject * obj1 = 0 ;
31909 char * kwnames[] = {
31910 (char *) "self",(char *) "maxSize", NULL
31911 };
31912
31913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31915 if (!SWIG_IsOK(res1)) {
31916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31917 }
31918 arg1 = reinterpret_cast< wxWindow * >(argp1);
31919 {
31920 arg2 = &temp2;
31921 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31922 }
31923 {
31924 PyThreadState* __tstate = wxPyBeginAllowThreads();
31925 (arg1)->SetMaxSize((wxSize const &)*arg2);
31926 wxPyEndAllowThreads(__tstate);
31927 if (PyErr_Occurred()) SWIG_fail;
31928 }
31929 resultobj = SWIG_Py_Void();
31930 return resultobj;
31931 fail:
31932 return NULL;
31933 }
31934
31935
31936 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31937 PyObject *resultobj = 0;
31938 wxWindow *arg1 = (wxWindow *) 0 ;
31939 int result;
31940 void *argp1 = 0 ;
31941 int res1 = 0 ;
31942 PyObject *swig_obj[1] ;
31943
31944 if (!args) SWIG_fail;
31945 swig_obj[0] = args;
31946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31947 if (!SWIG_IsOK(res1)) {
31948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31949 }
31950 arg1 = reinterpret_cast< wxWindow * >(argp1);
31951 {
31952 PyThreadState* __tstate = wxPyBeginAllowThreads();
31953 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31954 wxPyEndAllowThreads(__tstate);
31955 if (PyErr_Occurred()) SWIG_fail;
31956 }
31957 resultobj = SWIG_From_int(static_cast< int >(result));
31958 return resultobj;
31959 fail:
31960 return NULL;
31961 }
31962
31963
31964 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31965 PyObject *resultobj = 0;
31966 wxWindow *arg1 = (wxWindow *) 0 ;
31967 int result;
31968 void *argp1 = 0 ;
31969 int res1 = 0 ;
31970 PyObject *swig_obj[1] ;
31971
31972 if (!args) SWIG_fail;
31973 swig_obj[0] = args;
31974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31975 if (!SWIG_IsOK(res1)) {
31976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31977 }
31978 arg1 = reinterpret_cast< wxWindow * >(argp1);
31979 {
31980 PyThreadState* __tstate = wxPyBeginAllowThreads();
31981 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31982 wxPyEndAllowThreads(__tstate);
31983 if (PyErr_Occurred()) SWIG_fail;
31984 }
31985 resultobj = SWIG_From_int(static_cast< int >(result));
31986 return resultobj;
31987 fail:
31988 return NULL;
31989 }
31990
31991
31992 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31993 PyObject *resultobj = 0;
31994 wxWindow *arg1 = (wxWindow *) 0 ;
31995 int result;
31996 void *argp1 = 0 ;
31997 int res1 = 0 ;
31998 PyObject *swig_obj[1] ;
31999
32000 if (!args) SWIG_fail;
32001 swig_obj[0] = args;
32002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32003 if (!SWIG_IsOK(res1)) {
32004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32005 }
32006 arg1 = reinterpret_cast< wxWindow * >(argp1);
32007 {
32008 PyThreadState* __tstate = wxPyBeginAllowThreads();
32009 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32010 wxPyEndAllowThreads(__tstate);
32011 if (PyErr_Occurred()) SWIG_fail;
32012 }
32013 resultobj = SWIG_From_int(static_cast< int >(result));
32014 return resultobj;
32015 fail:
32016 return NULL;
32017 }
32018
32019
32020 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32021 PyObject *resultobj = 0;
32022 wxWindow *arg1 = (wxWindow *) 0 ;
32023 int result;
32024 void *argp1 = 0 ;
32025 int res1 = 0 ;
32026 PyObject *swig_obj[1] ;
32027
32028 if (!args) SWIG_fail;
32029 swig_obj[0] = args;
32030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32031 if (!SWIG_IsOK(res1)) {
32032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32033 }
32034 arg1 = reinterpret_cast< wxWindow * >(argp1);
32035 {
32036 PyThreadState* __tstate = wxPyBeginAllowThreads();
32037 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32038 wxPyEndAllowThreads(__tstate);
32039 if (PyErr_Occurred()) SWIG_fail;
32040 }
32041 resultobj = SWIG_From_int(static_cast< int >(result));
32042 return resultobj;
32043 fail:
32044 return NULL;
32045 }
32046
32047
32048 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32049 PyObject *resultobj = 0;
32050 wxWindow *arg1 = (wxWindow *) 0 ;
32051 wxSize *arg2 = 0 ;
32052 void *argp1 = 0 ;
32053 int res1 = 0 ;
32054 wxSize temp2 ;
32055 PyObject * obj0 = 0 ;
32056 PyObject * obj1 = 0 ;
32057 char * kwnames[] = {
32058 (char *) "self",(char *) "size", NULL
32059 };
32060
32061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32063 if (!SWIG_IsOK(res1)) {
32064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32065 }
32066 arg1 = reinterpret_cast< wxWindow * >(argp1);
32067 {
32068 arg2 = &temp2;
32069 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32070 }
32071 {
32072 PyThreadState* __tstate = wxPyBeginAllowThreads();
32073 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32074 wxPyEndAllowThreads(__tstate);
32075 if (PyErr_Occurred()) SWIG_fail;
32076 }
32077 resultobj = SWIG_Py_Void();
32078 return resultobj;
32079 fail:
32080 return NULL;
32081 }
32082
32083
32084 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32085 PyObject *resultobj = 0;
32086 wxWindow *arg1 = (wxWindow *) 0 ;
32087 int arg2 ;
32088 int arg3 ;
32089 void *argp1 = 0 ;
32090 int res1 = 0 ;
32091 int val2 ;
32092 int ecode2 = 0 ;
32093 int val3 ;
32094 int ecode3 = 0 ;
32095 PyObject * obj0 = 0 ;
32096 PyObject * obj1 = 0 ;
32097 PyObject * obj2 = 0 ;
32098 char * kwnames[] = {
32099 (char *) "self",(char *) "w",(char *) "h", NULL
32100 };
32101
32102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32104 if (!SWIG_IsOK(res1)) {
32105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32106 }
32107 arg1 = reinterpret_cast< wxWindow * >(argp1);
32108 ecode2 = SWIG_AsVal_int(obj1, &val2);
32109 if (!SWIG_IsOK(ecode2)) {
32110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32111 }
32112 arg2 = static_cast< int >(val2);
32113 ecode3 = SWIG_AsVal_int(obj2, &val3);
32114 if (!SWIG_IsOK(ecode3)) {
32115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32116 }
32117 arg3 = static_cast< int >(val3);
32118 {
32119 PyThreadState* __tstate = wxPyBeginAllowThreads();
32120 (arg1)->SetVirtualSize(arg2,arg3);
32121 wxPyEndAllowThreads(__tstate);
32122 if (PyErr_Occurred()) SWIG_fail;
32123 }
32124 resultobj = SWIG_Py_Void();
32125 return resultobj;
32126 fail:
32127 return NULL;
32128 }
32129
32130
32131 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32132 PyObject *resultobj = 0;
32133 wxWindow *arg1 = (wxWindow *) 0 ;
32134 wxSize result;
32135 void *argp1 = 0 ;
32136 int res1 = 0 ;
32137 PyObject *swig_obj[1] ;
32138
32139 if (!args) SWIG_fail;
32140 swig_obj[0] = args;
32141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32142 if (!SWIG_IsOK(res1)) {
32143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32144 }
32145 arg1 = reinterpret_cast< wxWindow * >(argp1);
32146 {
32147 PyThreadState* __tstate = wxPyBeginAllowThreads();
32148 result = ((wxWindow const *)arg1)->GetVirtualSize();
32149 wxPyEndAllowThreads(__tstate);
32150 if (PyErr_Occurred()) SWIG_fail;
32151 }
32152 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32153 return resultobj;
32154 fail:
32155 return NULL;
32156 }
32157
32158
32159 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32160 PyObject *resultobj = 0;
32161 wxWindow *arg1 = (wxWindow *) 0 ;
32162 int *arg2 = (int *) 0 ;
32163 int *arg3 = (int *) 0 ;
32164 void *argp1 = 0 ;
32165 int res1 = 0 ;
32166 int temp2 ;
32167 int res2 = SWIG_TMPOBJ ;
32168 int temp3 ;
32169 int res3 = SWIG_TMPOBJ ;
32170 PyObject *swig_obj[1] ;
32171
32172 arg2 = &temp2;
32173 arg3 = &temp3;
32174 if (!args) SWIG_fail;
32175 swig_obj[0] = args;
32176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32177 if (!SWIG_IsOK(res1)) {
32178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32179 }
32180 arg1 = reinterpret_cast< wxWindow * >(argp1);
32181 {
32182 PyThreadState* __tstate = wxPyBeginAllowThreads();
32183 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32184 wxPyEndAllowThreads(__tstate);
32185 if (PyErr_Occurred()) SWIG_fail;
32186 }
32187 resultobj = SWIG_Py_Void();
32188 if (SWIG_IsTmpObj(res2)) {
32189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32190 } else {
32191 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32193 }
32194 if (SWIG_IsTmpObj(res3)) {
32195 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32196 } else {
32197 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32198 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32199 }
32200 return resultobj;
32201 fail:
32202 return NULL;
32203 }
32204
32205
32206 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32207 PyObject *resultobj = 0;
32208 wxWindow *arg1 = (wxWindow *) 0 ;
32209 wxSize result;
32210 void *argp1 = 0 ;
32211 int res1 = 0 ;
32212 PyObject *swig_obj[1] ;
32213
32214 if (!args) SWIG_fail;
32215 swig_obj[0] = args;
32216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32217 if (!SWIG_IsOK(res1)) {
32218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32219 }
32220 arg1 = reinterpret_cast< wxWindow * >(argp1);
32221 {
32222 PyThreadState* __tstate = wxPyBeginAllowThreads();
32223 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32224 wxPyEndAllowThreads(__tstate);
32225 if (PyErr_Occurred()) SWIG_fail;
32226 }
32227 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32228 return resultobj;
32229 fail:
32230 return NULL;
32231 }
32232
32233
32234 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32235 PyObject *resultobj = 0;
32236 wxWindow *arg1 = (wxWindow *) 0 ;
32237 bool arg2 = (bool) true ;
32238 bool result;
32239 void *argp1 = 0 ;
32240 int res1 = 0 ;
32241 bool val2 ;
32242 int ecode2 = 0 ;
32243 PyObject * obj0 = 0 ;
32244 PyObject * obj1 = 0 ;
32245 char * kwnames[] = {
32246 (char *) "self",(char *) "show", NULL
32247 };
32248
32249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32251 if (!SWIG_IsOK(res1)) {
32252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32253 }
32254 arg1 = reinterpret_cast< wxWindow * >(argp1);
32255 if (obj1) {
32256 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32257 if (!SWIG_IsOK(ecode2)) {
32258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32259 }
32260 arg2 = static_cast< bool >(val2);
32261 }
32262 {
32263 PyThreadState* __tstate = wxPyBeginAllowThreads();
32264 result = (bool)(arg1)->Show(arg2);
32265 wxPyEndAllowThreads(__tstate);
32266 if (PyErr_Occurred()) SWIG_fail;
32267 }
32268 {
32269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32270 }
32271 return resultobj;
32272 fail:
32273 return NULL;
32274 }
32275
32276
32277 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32278 PyObject *resultobj = 0;
32279 wxWindow *arg1 = (wxWindow *) 0 ;
32280 bool result;
32281 void *argp1 = 0 ;
32282 int res1 = 0 ;
32283 PyObject *swig_obj[1] ;
32284
32285 if (!args) SWIG_fail;
32286 swig_obj[0] = args;
32287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32288 if (!SWIG_IsOK(res1)) {
32289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32290 }
32291 arg1 = reinterpret_cast< wxWindow * >(argp1);
32292 {
32293 PyThreadState* __tstate = wxPyBeginAllowThreads();
32294 result = (bool)(arg1)->Hide();
32295 wxPyEndAllowThreads(__tstate);
32296 if (PyErr_Occurred()) SWIG_fail;
32297 }
32298 {
32299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32300 }
32301 return resultobj;
32302 fail:
32303 return NULL;
32304 }
32305
32306
32307 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32308 PyObject *resultobj = 0;
32309 wxWindow *arg1 = (wxWindow *) 0 ;
32310 bool arg2 = (bool) true ;
32311 bool result;
32312 void *argp1 = 0 ;
32313 int res1 = 0 ;
32314 bool val2 ;
32315 int ecode2 = 0 ;
32316 PyObject * obj0 = 0 ;
32317 PyObject * obj1 = 0 ;
32318 char * kwnames[] = {
32319 (char *) "self",(char *) "enable", NULL
32320 };
32321
32322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32324 if (!SWIG_IsOK(res1)) {
32325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32326 }
32327 arg1 = reinterpret_cast< wxWindow * >(argp1);
32328 if (obj1) {
32329 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32330 if (!SWIG_IsOK(ecode2)) {
32331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32332 }
32333 arg2 = static_cast< bool >(val2);
32334 }
32335 {
32336 PyThreadState* __tstate = wxPyBeginAllowThreads();
32337 result = (bool)(arg1)->Enable(arg2);
32338 wxPyEndAllowThreads(__tstate);
32339 if (PyErr_Occurred()) SWIG_fail;
32340 }
32341 {
32342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32343 }
32344 return resultobj;
32345 fail:
32346 return NULL;
32347 }
32348
32349
32350 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32351 PyObject *resultobj = 0;
32352 wxWindow *arg1 = (wxWindow *) 0 ;
32353 bool result;
32354 void *argp1 = 0 ;
32355 int res1 = 0 ;
32356 PyObject *swig_obj[1] ;
32357
32358 if (!args) SWIG_fail;
32359 swig_obj[0] = args;
32360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32361 if (!SWIG_IsOK(res1)) {
32362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32363 }
32364 arg1 = reinterpret_cast< wxWindow * >(argp1);
32365 {
32366 PyThreadState* __tstate = wxPyBeginAllowThreads();
32367 result = (bool)(arg1)->Disable();
32368 wxPyEndAllowThreads(__tstate);
32369 if (PyErr_Occurred()) SWIG_fail;
32370 }
32371 {
32372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32373 }
32374 return resultobj;
32375 fail:
32376 return NULL;
32377 }
32378
32379
32380 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32381 PyObject *resultobj = 0;
32382 wxWindow *arg1 = (wxWindow *) 0 ;
32383 bool result;
32384 void *argp1 = 0 ;
32385 int res1 = 0 ;
32386 PyObject *swig_obj[1] ;
32387
32388 if (!args) SWIG_fail;
32389 swig_obj[0] = args;
32390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32391 if (!SWIG_IsOK(res1)) {
32392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32393 }
32394 arg1 = reinterpret_cast< wxWindow * >(argp1);
32395 {
32396 PyThreadState* __tstate = wxPyBeginAllowThreads();
32397 result = (bool)((wxWindow const *)arg1)->IsShown();
32398 wxPyEndAllowThreads(__tstate);
32399 if (PyErr_Occurred()) SWIG_fail;
32400 }
32401 {
32402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32403 }
32404 return resultobj;
32405 fail:
32406 return NULL;
32407 }
32408
32409
32410 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32411 PyObject *resultobj = 0;
32412 wxWindow *arg1 = (wxWindow *) 0 ;
32413 bool result;
32414 void *argp1 = 0 ;
32415 int res1 = 0 ;
32416 PyObject *swig_obj[1] ;
32417
32418 if (!args) SWIG_fail;
32419 swig_obj[0] = args;
32420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32421 if (!SWIG_IsOK(res1)) {
32422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32423 }
32424 arg1 = reinterpret_cast< wxWindow * >(argp1);
32425 {
32426 PyThreadState* __tstate = wxPyBeginAllowThreads();
32427 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32428 wxPyEndAllowThreads(__tstate);
32429 if (PyErr_Occurred()) SWIG_fail;
32430 }
32431 {
32432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32433 }
32434 return resultobj;
32435 fail:
32436 return NULL;
32437 }
32438
32439
32440 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32441 PyObject *resultobj = 0;
32442 wxWindow *arg1 = (wxWindow *) 0 ;
32443 long arg2 ;
32444 void *argp1 = 0 ;
32445 int res1 = 0 ;
32446 long val2 ;
32447 int ecode2 = 0 ;
32448 PyObject * obj0 = 0 ;
32449 PyObject * obj1 = 0 ;
32450 char * kwnames[] = {
32451 (char *) "self",(char *) "style", NULL
32452 };
32453
32454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32456 if (!SWIG_IsOK(res1)) {
32457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32458 }
32459 arg1 = reinterpret_cast< wxWindow * >(argp1);
32460 ecode2 = SWIG_AsVal_long(obj1, &val2);
32461 if (!SWIG_IsOK(ecode2)) {
32462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32463 }
32464 arg2 = static_cast< long >(val2);
32465 {
32466 PyThreadState* __tstate = wxPyBeginAllowThreads();
32467 (arg1)->SetWindowStyleFlag(arg2);
32468 wxPyEndAllowThreads(__tstate);
32469 if (PyErr_Occurred()) SWIG_fail;
32470 }
32471 resultobj = SWIG_Py_Void();
32472 return resultobj;
32473 fail:
32474 return NULL;
32475 }
32476
32477
32478 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32479 PyObject *resultobj = 0;
32480 wxWindow *arg1 = (wxWindow *) 0 ;
32481 long result;
32482 void *argp1 = 0 ;
32483 int res1 = 0 ;
32484 PyObject *swig_obj[1] ;
32485
32486 if (!args) SWIG_fail;
32487 swig_obj[0] = args;
32488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32489 if (!SWIG_IsOK(res1)) {
32490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32491 }
32492 arg1 = reinterpret_cast< wxWindow * >(argp1);
32493 {
32494 PyThreadState* __tstate = wxPyBeginAllowThreads();
32495 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32496 wxPyEndAllowThreads(__tstate);
32497 if (PyErr_Occurred()) SWIG_fail;
32498 }
32499 resultobj = SWIG_From_long(static_cast< long >(result));
32500 return resultobj;
32501 fail:
32502 return NULL;
32503 }
32504
32505
32506 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32507 PyObject *resultobj = 0;
32508 wxWindow *arg1 = (wxWindow *) 0 ;
32509 int arg2 ;
32510 bool result;
32511 void *argp1 = 0 ;
32512 int res1 = 0 ;
32513 int val2 ;
32514 int ecode2 = 0 ;
32515 PyObject * obj0 = 0 ;
32516 PyObject * obj1 = 0 ;
32517 char * kwnames[] = {
32518 (char *) "self",(char *) "flag", NULL
32519 };
32520
32521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32523 if (!SWIG_IsOK(res1)) {
32524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32525 }
32526 arg1 = reinterpret_cast< wxWindow * >(argp1);
32527 ecode2 = SWIG_AsVal_int(obj1, &val2);
32528 if (!SWIG_IsOK(ecode2)) {
32529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32530 }
32531 arg2 = static_cast< int >(val2);
32532 {
32533 PyThreadState* __tstate = wxPyBeginAllowThreads();
32534 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32535 wxPyEndAllowThreads(__tstate);
32536 if (PyErr_Occurred()) SWIG_fail;
32537 }
32538 {
32539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32540 }
32541 return resultobj;
32542 fail:
32543 return NULL;
32544 }
32545
32546
32547 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32548 PyObject *resultobj = 0;
32549 wxWindow *arg1 = (wxWindow *) 0 ;
32550 bool result;
32551 void *argp1 = 0 ;
32552 int res1 = 0 ;
32553 PyObject *swig_obj[1] ;
32554
32555 if (!args) SWIG_fail;
32556 swig_obj[0] = args;
32557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32558 if (!SWIG_IsOK(res1)) {
32559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32560 }
32561 arg1 = reinterpret_cast< wxWindow * >(argp1);
32562 {
32563 PyThreadState* __tstate = wxPyBeginAllowThreads();
32564 result = (bool)((wxWindow const *)arg1)->IsRetained();
32565 wxPyEndAllowThreads(__tstate);
32566 if (PyErr_Occurred()) SWIG_fail;
32567 }
32568 {
32569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32570 }
32571 return resultobj;
32572 fail:
32573 return NULL;
32574 }
32575
32576
32577 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32578 PyObject *resultobj = 0;
32579 wxWindow *arg1 = (wxWindow *) 0 ;
32580 long arg2 ;
32581 void *argp1 = 0 ;
32582 int res1 = 0 ;
32583 long val2 ;
32584 int ecode2 = 0 ;
32585 PyObject * obj0 = 0 ;
32586 PyObject * obj1 = 0 ;
32587 char * kwnames[] = {
32588 (char *) "self",(char *) "exStyle", NULL
32589 };
32590
32591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32593 if (!SWIG_IsOK(res1)) {
32594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32595 }
32596 arg1 = reinterpret_cast< wxWindow * >(argp1);
32597 ecode2 = SWIG_AsVal_long(obj1, &val2);
32598 if (!SWIG_IsOK(ecode2)) {
32599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32600 }
32601 arg2 = static_cast< long >(val2);
32602 {
32603 PyThreadState* __tstate = wxPyBeginAllowThreads();
32604 (arg1)->SetExtraStyle(arg2);
32605 wxPyEndAllowThreads(__tstate);
32606 if (PyErr_Occurred()) SWIG_fail;
32607 }
32608 resultobj = SWIG_Py_Void();
32609 return resultobj;
32610 fail:
32611 return NULL;
32612 }
32613
32614
32615 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32616 PyObject *resultobj = 0;
32617 wxWindow *arg1 = (wxWindow *) 0 ;
32618 long result;
32619 void *argp1 = 0 ;
32620 int res1 = 0 ;
32621 PyObject *swig_obj[1] ;
32622
32623 if (!args) SWIG_fail;
32624 swig_obj[0] = args;
32625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32626 if (!SWIG_IsOK(res1)) {
32627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32628 }
32629 arg1 = reinterpret_cast< wxWindow * >(argp1);
32630 {
32631 PyThreadState* __tstate = wxPyBeginAllowThreads();
32632 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32633 wxPyEndAllowThreads(__tstate);
32634 if (PyErr_Occurred()) SWIG_fail;
32635 }
32636 resultobj = SWIG_From_long(static_cast< long >(result));
32637 return resultobj;
32638 fail:
32639 return NULL;
32640 }
32641
32642
32643 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32644 PyObject *resultobj = 0;
32645 wxWindow *arg1 = (wxWindow *) 0 ;
32646 bool arg2 = (bool) true ;
32647 void *argp1 = 0 ;
32648 int res1 = 0 ;
32649 bool val2 ;
32650 int ecode2 = 0 ;
32651 PyObject * obj0 = 0 ;
32652 PyObject * obj1 = 0 ;
32653 char * kwnames[] = {
32654 (char *) "self",(char *) "modal", NULL
32655 };
32656
32657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32659 if (!SWIG_IsOK(res1)) {
32660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32661 }
32662 arg1 = reinterpret_cast< wxWindow * >(argp1);
32663 if (obj1) {
32664 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32665 if (!SWIG_IsOK(ecode2)) {
32666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32667 }
32668 arg2 = static_cast< bool >(val2);
32669 }
32670 {
32671 PyThreadState* __tstate = wxPyBeginAllowThreads();
32672 (arg1)->MakeModal(arg2);
32673 wxPyEndAllowThreads(__tstate);
32674 if (PyErr_Occurred()) SWIG_fail;
32675 }
32676 resultobj = SWIG_Py_Void();
32677 return resultobj;
32678 fail:
32679 return NULL;
32680 }
32681
32682
32683 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32684 PyObject *resultobj = 0;
32685 wxWindow *arg1 = (wxWindow *) 0 ;
32686 bool arg2 ;
32687 void *argp1 = 0 ;
32688 int res1 = 0 ;
32689 bool val2 ;
32690 int ecode2 = 0 ;
32691 PyObject * obj0 = 0 ;
32692 PyObject * obj1 = 0 ;
32693 char * kwnames[] = {
32694 (char *) "self",(char *) "enableTheme", NULL
32695 };
32696
32697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32699 if (!SWIG_IsOK(res1)) {
32700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32701 }
32702 arg1 = reinterpret_cast< wxWindow * >(argp1);
32703 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32704 if (!SWIG_IsOK(ecode2)) {
32705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32706 }
32707 arg2 = static_cast< bool >(val2);
32708 {
32709 PyThreadState* __tstate = wxPyBeginAllowThreads();
32710 (arg1)->SetThemeEnabled(arg2);
32711 wxPyEndAllowThreads(__tstate);
32712 if (PyErr_Occurred()) SWIG_fail;
32713 }
32714 resultobj = SWIG_Py_Void();
32715 return resultobj;
32716 fail:
32717 return NULL;
32718 }
32719
32720
32721 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32722 PyObject *resultobj = 0;
32723 wxWindow *arg1 = (wxWindow *) 0 ;
32724 bool result;
32725 void *argp1 = 0 ;
32726 int res1 = 0 ;
32727 PyObject *swig_obj[1] ;
32728
32729 if (!args) SWIG_fail;
32730 swig_obj[0] = args;
32731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32732 if (!SWIG_IsOK(res1)) {
32733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32734 }
32735 arg1 = reinterpret_cast< wxWindow * >(argp1);
32736 {
32737 PyThreadState* __tstate = wxPyBeginAllowThreads();
32738 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32739 wxPyEndAllowThreads(__tstate);
32740 if (PyErr_Occurred()) SWIG_fail;
32741 }
32742 {
32743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32744 }
32745 return resultobj;
32746 fail:
32747 return NULL;
32748 }
32749
32750
32751 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32752 PyObject *resultobj = 0;
32753 wxWindow *arg1 = (wxWindow *) 0 ;
32754 void *argp1 = 0 ;
32755 int res1 = 0 ;
32756 PyObject *swig_obj[1] ;
32757
32758 if (!args) SWIG_fail;
32759 swig_obj[0] = args;
32760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32761 if (!SWIG_IsOK(res1)) {
32762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32763 }
32764 arg1 = reinterpret_cast< wxWindow * >(argp1);
32765 {
32766 PyThreadState* __tstate = wxPyBeginAllowThreads();
32767 (arg1)->SetFocus();
32768 wxPyEndAllowThreads(__tstate);
32769 if (PyErr_Occurred()) SWIG_fail;
32770 }
32771 resultobj = SWIG_Py_Void();
32772 return resultobj;
32773 fail:
32774 return NULL;
32775 }
32776
32777
32778 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32779 PyObject *resultobj = 0;
32780 wxWindow *arg1 = (wxWindow *) 0 ;
32781 void *argp1 = 0 ;
32782 int res1 = 0 ;
32783 PyObject *swig_obj[1] ;
32784
32785 if (!args) SWIG_fail;
32786 swig_obj[0] = args;
32787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32788 if (!SWIG_IsOK(res1)) {
32789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32790 }
32791 arg1 = reinterpret_cast< wxWindow * >(argp1);
32792 {
32793 PyThreadState* __tstate = wxPyBeginAllowThreads();
32794 (arg1)->SetFocusFromKbd();
32795 wxPyEndAllowThreads(__tstate);
32796 if (PyErr_Occurred()) SWIG_fail;
32797 }
32798 resultobj = SWIG_Py_Void();
32799 return resultobj;
32800 fail:
32801 return NULL;
32802 }
32803
32804
32805 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32806 PyObject *resultobj = 0;
32807 wxWindow *result = 0 ;
32808
32809 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32810 {
32811 if (!wxPyCheckForApp()) SWIG_fail;
32812 PyThreadState* __tstate = wxPyBeginAllowThreads();
32813 result = (wxWindow *)wxWindow::FindFocus();
32814 wxPyEndAllowThreads(__tstate);
32815 if (PyErr_Occurred()) SWIG_fail;
32816 }
32817 {
32818 resultobj = wxPyMake_wxObject(result, 0);
32819 }
32820 return resultobj;
32821 fail:
32822 return NULL;
32823 }
32824
32825
32826 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32827 PyObject *resultobj = 0;
32828 wxWindow *arg1 = (wxWindow *) 0 ;
32829 bool result;
32830 void *argp1 = 0 ;
32831 int res1 = 0 ;
32832 PyObject *swig_obj[1] ;
32833
32834 if (!args) SWIG_fail;
32835 swig_obj[0] = args;
32836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32837 if (!SWIG_IsOK(res1)) {
32838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32839 }
32840 arg1 = reinterpret_cast< wxWindow * >(argp1);
32841 {
32842 PyThreadState* __tstate = wxPyBeginAllowThreads();
32843 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32844 wxPyEndAllowThreads(__tstate);
32845 if (PyErr_Occurred()) SWIG_fail;
32846 }
32847 {
32848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32849 }
32850 return resultobj;
32851 fail:
32852 return NULL;
32853 }
32854
32855
32856 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32857 PyObject *resultobj = 0;
32858 wxWindow *arg1 = (wxWindow *) 0 ;
32859 bool result;
32860 void *argp1 = 0 ;
32861 int res1 = 0 ;
32862 PyObject *swig_obj[1] ;
32863
32864 if (!args) SWIG_fail;
32865 swig_obj[0] = args;
32866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32867 if (!SWIG_IsOK(res1)) {
32868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32869 }
32870 arg1 = reinterpret_cast< wxWindow * >(argp1);
32871 {
32872 PyThreadState* __tstate = wxPyBeginAllowThreads();
32873 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32874 wxPyEndAllowThreads(__tstate);
32875 if (PyErr_Occurred()) SWIG_fail;
32876 }
32877 {
32878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32879 }
32880 return resultobj;
32881 fail:
32882 return NULL;
32883 }
32884
32885
32886 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32887 PyObject *resultobj = 0;
32888 wxWindow *arg1 = (wxWindow *) 0 ;
32889 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32890 bool result;
32891 void *argp1 = 0 ;
32892 int res1 = 0 ;
32893 int val2 ;
32894 int ecode2 = 0 ;
32895 PyObject * obj0 = 0 ;
32896 PyObject * obj1 = 0 ;
32897 char * kwnames[] = {
32898 (char *) "self",(char *) "flags", NULL
32899 };
32900
32901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32903 if (!SWIG_IsOK(res1)) {
32904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32905 }
32906 arg1 = reinterpret_cast< wxWindow * >(argp1);
32907 if (obj1) {
32908 ecode2 = SWIG_AsVal_int(obj1, &val2);
32909 if (!SWIG_IsOK(ecode2)) {
32910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32911 }
32912 arg2 = static_cast< int >(val2);
32913 }
32914 {
32915 PyThreadState* __tstate = wxPyBeginAllowThreads();
32916 result = (bool)(arg1)->Navigate(arg2);
32917 wxPyEndAllowThreads(__tstate);
32918 if (PyErr_Occurred()) SWIG_fail;
32919 }
32920 {
32921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32922 }
32923 return resultobj;
32924 fail:
32925 return NULL;
32926 }
32927
32928
32929 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32930 PyObject *resultobj = 0;
32931 wxWindow *arg1 = (wxWindow *) 0 ;
32932 wxWindow *arg2 = (wxWindow *) 0 ;
32933 void *argp1 = 0 ;
32934 int res1 = 0 ;
32935 void *argp2 = 0 ;
32936 int res2 = 0 ;
32937 PyObject * obj0 = 0 ;
32938 PyObject * obj1 = 0 ;
32939 char * kwnames[] = {
32940 (char *) "self",(char *) "win", NULL
32941 };
32942
32943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32945 if (!SWIG_IsOK(res1)) {
32946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32947 }
32948 arg1 = reinterpret_cast< wxWindow * >(argp1);
32949 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32950 if (!SWIG_IsOK(res2)) {
32951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32952 }
32953 arg2 = reinterpret_cast< wxWindow * >(argp2);
32954 {
32955 PyThreadState* __tstate = wxPyBeginAllowThreads();
32956 (arg1)->MoveAfterInTabOrder(arg2);
32957 wxPyEndAllowThreads(__tstate);
32958 if (PyErr_Occurred()) SWIG_fail;
32959 }
32960 resultobj = SWIG_Py_Void();
32961 return resultobj;
32962 fail:
32963 return NULL;
32964 }
32965
32966
32967 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32968 PyObject *resultobj = 0;
32969 wxWindow *arg1 = (wxWindow *) 0 ;
32970 wxWindow *arg2 = (wxWindow *) 0 ;
32971 void *argp1 = 0 ;
32972 int res1 = 0 ;
32973 void *argp2 = 0 ;
32974 int res2 = 0 ;
32975 PyObject * obj0 = 0 ;
32976 PyObject * obj1 = 0 ;
32977 char * kwnames[] = {
32978 (char *) "self",(char *) "win", NULL
32979 };
32980
32981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32983 if (!SWIG_IsOK(res1)) {
32984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32985 }
32986 arg1 = reinterpret_cast< wxWindow * >(argp1);
32987 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32988 if (!SWIG_IsOK(res2)) {
32989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32990 }
32991 arg2 = reinterpret_cast< wxWindow * >(argp2);
32992 {
32993 PyThreadState* __tstate = wxPyBeginAllowThreads();
32994 (arg1)->MoveBeforeInTabOrder(arg2);
32995 wxPyEndAllowThreads(__tstate);
32996 if (PyErr_Occurred()) SWIG_fail;
32997 }
32998 resultobj = SWIG_Py_Void();
32999 return resultobj;
33000 fail:
33001 return NULL;
33002 }
33003
33004
33005 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33006 PyObject *resultobj = 0;
33007 wxWindow *arg1 = (wxWindow *) 0 ;
33008 PyObject *result = 0 ;
33009 void *argp1 = 0 ;
33010 int res1 = 0 ;
33011 PyObject *swig_obj[1] ;
33012
33013 if (!args) SWIG_fail;
33014 swig_obj[0] = args;
33015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33016 if (!SWIG_IsOK(res1)) {
33017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33018 }
33019 arg1 = reinterpret_cast< wxWindow * >(argp1);
33020 {
33021 PyThreadState* __tstate = wxPyBeginAllowThreads();
33022 result = (PyObject *)wxWindow_GetChildren(arg1);
33023 wxPyEndAllowThreads(__tstate);
33024 if (PyErr_Occurred()) SWIG_fail;
33025 }
33026 resultobj = result;
33027 return resultobj;
33028 fail:
33029 return NULL;
33030 }
33031
33032
33033 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33034 PyObject *resultobj = 0;
33035 wxWindow *arg1 = (wxWindow *) 0 ;
33036 wxWindow *result = 0 ;
33037 void *argp1 = 0 ;
33038 int res1 = 0 ;
33039 PyObject *swig_obj[1] ;
33040
33041 if (!args) SWIG_fail;
33042 swig_obj[0] = args;
33043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33044 if (!SWIG_IsOK(res1)) {
33045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33046 }
33047 arg1 = reinterpret_cast< wxWindow * >(argp1);
33048 {
33049 PyThreadState* __tstate = wxPyBeginAllowThreads();
33050 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33051 wxPyEndAllowThreads(__tstate);
33052 if (PyErr_Occurred()) SWIG_fail;
33053 }
33054 {
33055 resultobj = wxPyMake_wxObject(result, 0);
33056 }
33057 return resultobj;
33058 fail:
33059 return NULL;
33060 }
33061
33062
33063 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33064 PyObject *resultobj = 0;
33065 wxWindow *arg1 = (wxWindow *) 0 ;
33066 wxWindow *result = 0 ;
33067 void *argp1 = 0 ;
33068 int res1 = 0 ;
33069 PyObject *swig_obj[1] ;
33070
33071 if (!args) SWIG_fail;
33072 swig_obj[0] = args;
33073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33074 if (!SWIG_IsOK(res1)) {
33075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33076 }
33077 arg1 = reinterpret_cast< wxWindow * >(argp1);
33078 {
33079 PyThreadState* __tstate = wxPyBeginAllowThreads();
33080 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33081 wxPyEndAllowThreads(__tstate);
33082 if (PyErr_Occurred()) SWIG_fail;
33083 }
33084 {
33085 resultobj = wxPyMake_wxObject(result, 0);
33086 }
33087 return resultobj;
33088 fail:
33089 return NULL;
33090 }
33091
33092
33093 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33094 PyObject *resultobj = 0;
33095 wxWindow *arg1 = (wxWindow *) 0 ;
33096 bool result;
33097 void *argp1 = 0 ;
33098 int res1 = 0 ;
33099 PyObject *swig_obj[1] ;
33100
33101 if (!args) SWIG_fail;
33102 swig_obj[0] = args;
33103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33104 if (!SWIG_IsOK(res1)) {
33105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33106 }
33107 arg1 = reinterpret_cast< wxWindow * >(argp1);
33108 {
33109 PyThreadState* __tstate = wxPyBeginAllowThreads();
33110 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33111 wxPyEndAllowThreads(__tstate);
33112 if (PyErr_Occurred()) SWIG_fail;
33113 }
33114 {
33115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33116 }
33117 return resultobj;
33118 fail:
33119 return NULL;
33120 }
33121
33122
33123 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33124 PyObject *resultobj = 0;
33125 wxWindow *arg1 = (wxWindow *) 0 ;
33126 wxWindow *arg2 = (wxWindow *) 0 ;
33127 bool result;
33128 void *argp1 = 0 ;
33129 int res1 = 0 ;
33130 void *argp2 = 0 ;
33131 int res2 = 0 ;
33132 PyObject * obj0 = 0 ;
33133 PyObject * obj1 = 0 ;
33134 char * kwnames[] = {
33135 (char *) "self",(char *) "newParent", NULL
33136 };
33137
33138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33140 if (!SWIG_IsOK(res1)) {
33141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33142 }
33143 arg1 = reinterpret_cast< wxWindow * >(argp1);
33144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33145 if (!SWIG_IsOK(res2)) {
33146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33147 }
33148 arg2 = reinterpret_cast< wxWindow * >(argp2);
33149 {
33150 PyThreadState* __tstate = wxPyBeginAllowThreads();
33151 result = (bool)(arg1)->Reparent(arg2);
33152 wxPyEndAllowThreads(__tstate);
33153 if (PyErr_Occurred()) SWIG_fail;
33154 }
33155 {
33156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33157 }
33158 return resultobj;
33159 fail:
33160 return NULL;
33161 }
33162
33163
33164 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33165 PyObject *resultobj = 0;
33166 wxWindow *arg1 = (wxWindow *) 0 ;
33167 wxWindow *arg2 = (wxWindow *) 0 ;
33168 void *argp1 = 0 ;
33169 int res1 = 0 ;
33170 void *argp2 = 0 ;
33171 int res2 = 0 ;
33172 PyObject * obj0 = 0 ;
33173 PyObject * obj1 = 0 ;
33174 char * kwnames[] = {
33175 (char *) "self",(char *) "child", NULL
33176 };
33177
33178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33180 if (!SWIG_IsOK(res1)) {
33181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33182 }
33183 arg1 = reinterpret_cast< wxWindow * >(argp1);
33184 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33185 if (!SWIG_IsOK(res2)) {
33186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33187 }
33188 arg2 = reinterpret_cast< wxWindow * >(argp2);
33189 {
33190 PyThreadState* __tstate = wxPyBeginAllowThreads();
33191 (arg1)->AddChild(arg2);
33192 wxPyEndAllowThreads(__tstate);
33193 if (PyErr_Occurred()) SWIG_fail;
33194 }
33195 resultobj = SWIG_Py_Void();
33196 return resultobj;
33197 fail:
33198 return NULL;
33199 }
33200
33201
33202 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33203 PyObject *resultobj = 0;
33204 wxWindow *arg1 = (wxWindow *) 0 ;
33205 wxWindow *arg2 = (wxWindow *) 0 ;
33206 void *argp1 = 0 ;
33207 int res1 = 0 ;
33208 void *argp2 = 0 ;
33209 int res2 = 0 ;
33210 PyObject * obj0 = 0 ;
33211 PyObject * obj1 = 0 ;
33212 char * kwnames[] = {
33213 (char *) "self",(char *) "child", NULL
33214 };
33215
33216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33218 if (!SWIG_IsOK(res1)) {
33219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33220 }
33221 arg1 = reinterpret_cast< wxWindow * >(argp1);
33222 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33223 if (!SWIG_IsOK(res2)) {
33224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33225 }
33226 arg2 = reinterpret_cast< wxWindow * >(argp2);
33227 {
33228 PyThreadState* __tstate = wxPyBeginAllowThreads();
33229 (arg1)->RemoveChild(arg2);
33230 wxPyEndAllowThreads(__tstate);
33231 if (PyErr_Occurred()) SWIG_fail;
33232 }
33233 resultobj = SWIG_Py_Void();
33234 return resultobj;
33235 fail:
33236 return NULL;
33237 }
33238
33239
33240 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33241 PyObject *resultobj = 0;
33242 wxWindow *arg1 = (wxWindow *) 0 ;
33243 bool arg2 ;
33244 void *argp1 = 0 ;
33245 int res1 = 0 ;
33246 bool val2 ;
33247 int ecode2 = 0 ;
33248 PyObject * obj0 = 0 ;
33249 PyObject * obj1 = 0 ;
33250 char * kwnames[] = {
33251 (char *) "self",(char *) "on", NULL
33252 };
33253
33254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33256 if (!SWIG_IsOK(res1)) {
33257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33258 }
33259 arg1 = reinterpret_cast< wxWindow * >(argp1);
33260 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33261 if (!SWIG_IsOK(ecode2)) {
33262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33263 }
33264 arg2 = static_cast< bool >(val2);
33265 {
33266 PyThreadState* __tstate = wxPyBeginAllowThreads();
33267 wxWindow_SetDoubleBuffered(arg1,arg2);
33268 wxPyEndAllowThreads(__tstate);
33269 if (PyErr_Occurred()) SWIG_fail;
33270 }
33271 resultobj = SWIG_Py_Void();
33272 return resultobj;
33273 fail:
33274 return NULL;
33275 }
33276
33277
33278 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33279 PyObject *resultobj = 0;
33280 wxWindow *arg1 = (wxWindow *) 0 ;
33281 long arg2 ;
33282 wxWindow *result = 0 ;
33283 void *argp1 = 0 ;
33284 int res1 = 0 ;
33285 long val2 ;
33286 int ecode2 = 0 ;
33287 PyObject * obj0 = 0 ;
33288 PyObject * obj1 = 0 ;
33289 char * kwnames[] = {
33290 (char *) "self",(char *) "winid", NULL
33291 };
33292
33293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33295 if (!SWIG_IsOK(res1)) {
33296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33297 }
33298 arg1 = reinterpret_cast< wxWindow * >(argp1);
33299 ecode2 = SWIG_AsVal_long(obj1, &val2);
33300 if (!SWIG_IsOK(ecode2)) {
33301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33302 }
33303 arg2 = static_cast< long >(val2);
33304 {
33305 PyThreadState* __tstate = wxPyBeginAllowThreads();
33306 result = (wxWindow *)(arg1)->FindWindow(arg2);
33307 wxPyEndAllowThreads(__tstate);
33308 if (PyErr_Occurred()) SWIG_fail;
33309 }
33310 {
33311 resultobj = wxPyMake_wxObject(result, 0);
33312 }
33313 return resultobj;
33314 fail:
33315 return NULL;
33316 }
33317
33318
33319 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33320 PyObject *resultobj = 0;
33321 wxWindow *arg1 = (wxWindow *) 0 ;
33322 wxString *arg2 = 0 ;
33323 wxWindow *result = 0 ;
33324 void *argp1 = 0 ;
33325 int res1 = 0 ;
33326 bool temp2 = false ;
33327 PyObject * obj0 = 0 ;
33328 PyObject * obj1 = 0 ;
33329 char * kwnames[] = {
33330 (char *) "self",(char *) "name", NULL
33331 };
33332
33333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33335 if (!SWIG_IsOK(res1)) {
33336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33337 }
33338 arg1 = reinterpret_cast< wxWindow * >(argp1);
33339 {
33340 arg2 = wxString_in_helper(obj1);
33341 if (arg2 == NULL) SWIG_fail;
33342 temp2 = true;
33343 }
33344 {
33345 PyThreadState* __tstate = wxPyBeginAllowThreads();
33346 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33347 wxPyEndAllowThreads(__tstate);
33348 if (PyErr_Occurred()) SWIG_fail;
33349 }
33350 {
33351 resultobj = wxPyMake_wxObject(result, 0);
33352 }
33353 {
33354 if (temp2)
33355 delete arg2;
33356 }
33357 return resultobj;
33358 fail:
33359 {
33360 if (temp2)
33361 delete arg2;
33362 }
33363 return NULL;
33364 }
33365
33366
33367 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33368 PyObject *resultobj = 0;
33369 wxWindow *arg1 = (wxWindow *) 0 ;
33370 wxEvtHandler *result = 0 ;
33371 void *argp1 = 0 ;
33372 int res1 = 0 ;
33373 PyObject *swig_obj[1] ;
33374
33375 if (!args) SWIG_fail;
33376 swig_obj[0] = args;
33377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33378 if (!SWIG_IsOK(res1)) {
33379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33380 }
33381 arg1 = reinterpret_cast< wxWindow * >(argp1);
33382 {
33383 PyThreadState* __tstate = wxPyBeginAllowThreads();
33384 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33385 wxPyEndAllowThreads(__tstate);
33386 if (PyErr_Occurred()) SWIG_fail;
33387 }
33388 {
33389 resultobj = wxPyMake_wxObject(result, 0);
33390 }
33391 return resultobj;
33392 fail:
33393 return NULL;
33394 }
33395
33396
33397 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33398 PyObject *resultobj = 0;
33399 wxWindow *arg1 = (wxWindow *) 0 ;
33400 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33401 void *argp1 = 0 ;
33402 int res1 = 0 ;
33403 void *argp2 = 0 ;
33404 int res2 = 0 ;
33405 PyObject * obj0 = 0 ;
33406 PyObject * obj1 = 0 ;
33407 char * kwnames[] = {
33408 (char *) "self",(char *) "handler", NULL
33409 };
33410
33411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33413 if (!SWIG_IsOK(res1)) {
33414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33415 }
33416 arg1 = reinterpret_cast< wxWindow * >(argp1);
33417 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33418 if (!SWIG_IsOK(res2)) {
33419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33420 }
33421 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33422 {
33423 PyThreadState* __tstate = wxPyBeginAllowThreads();
33424 (arg1)->SetEventHandler(arg2);
33425 wxPyEndAllowThreads(__tstate);
33426 if (PyErr_Occurred()) SWIG_fail;
33427 }
33428 resultobj = SWIG_Py_Void();
33429 return resultobj;
33430 fail:
33431 return NULL;
33432 }
33433
33434
33435 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33436 PyObject *resultobj = 0;
33437 wxWindow *arg1 = (wxWindow *) 0 ;
33438 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33439 void *argp1 = 0 ;
33440 int res1 = 0 ;
33441 void *argp2 = 0 ;
33442 int res2 = 0 ;
33443 PyObject * obj0 = 0 ;
33444 PyObject * obj1 = 0 ;
33445 char * kwnames[] = {
33446 (char *) "self",(char *) "handler", NULL
33447 };
33448
33449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33451 if (!SWIG_IsOK(res1)) {
33452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33453 }
33454 arg1 = reinterpret_cast< wxWindow * >(argp1);
33455 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33456 if (!SWIG_IsOK(res2)) {
33457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33458 }
33459 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33460 {
33461 PyThreadState* __tstate = wxPyBeginAllowThreads();
33462 (arg1)->PushEventHandler(arg2);
33463 wxPyEndAllowThreads(__tstate);
33464 if (PyErr_Occurred()) SWIG_fail;
33465 }
33466 resultobj = SWIG_Py_Void();
33467 return resultobj;
33468 fail:
33469 return NULL;
33470 }
33471
33472
33473 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33474 PyObject *resultobj = 0;
33475 wxWindow *arg1 = (wxWindow *) 0 ;
33476 bool arg2 = (bool) false ;
33477 wxEvtHandler *result = 0 ;
33478 void *argp1 = 0 ;
33479 int res1 = 0 ;
33480 bool val2 ;
33481 int ecode2 = 0 ;
33482 PyObject * obj0 = 0 ;
33483 PyObject * obj1 = 0 ;
33484 char * kwnames[] = {
33485 (char *) "self",(char *) "deleteHandler", NULL
33486 };
33487
33488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33490 if (!SWIG_IsOK(res1)) {
33491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33492 }
33493 arg1 = reinterpret_cast< wxWindow * >(argp1);
33494 if (obj1) {
33495 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33496 if (!SWIG_IsOK(ecode2)) {
33497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33498 }
33499 arg2 = static_cast< bool >(val2);
33500 }
33501 {
33502 PyThreadState* __tstate = wxPyBeginAllowThreads();
33503 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33504 wxPyEndAllowThreads(__tstate);
33505 if (PyErr_Occurred()) SWIG_fail;
33506 }
33507 {
33508 resultobj = wxPyMake_wxObject(result, 0);
33509 }
33510 return resultobj;
33511 fail:
33512 return NULL;
33513 }
33514
33515
33516 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33517 PyObject *resultobj = 0;
33518 wxWindow *arg1 = (wxWindow *) 0 ;
33519 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33520 bool result;
33521 void *argp1 = 0 ;
33522 int res1 = 0 ;
33523 void *argp2 = 0 ;
33524 int res2 = 0 ;
33525 PyObject * obj0 = 0 ;
33526 PyObject * obj1 = 0 ;
33527 char * kwnames[] = {
33528 (char *) "self",(char *) "handler", NULL
33529 };
33530
33531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33533 if (!SWIG_IsOK(res1)) {
33534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33535 }
33536 arg1 = reinterpret_cast< wxWindow * >(argp1);
33537 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33538 if (!SWIG_IsOK(res2)) {
33539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33540 }
33541 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33542 {
33543 PyThreadState* __tstate = wxPyBeginAllowThreads();
33544 result = (bool)(arg1)->RemoveEventHandler(arg2);
33545 wxPyEndAllowThreads(__tstate);
33546 if (PyErr_Occurred()) SWIG_fail;
33547 }
33548 {
33549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33550 }
33551 return resultobj;
33552 fail:
33553 return NULL;
33554 }
33555
33556
33557 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33558 PyObject *resultobj = 0;
33559 wxWindow *arg1 = (wxWindow *) 0 ;
33560 wxValidator *arg2 = 0 ;
33561 void *argp1 = 0 ;
33562 int res1 = 0 ;
33563 void *argp2 = 0 ;
33564 int res2 = 0 ;
33565 PyObject * obj0 = 0 ;
33566 PyObject * obj1 = 0 ;
33567 char * kwnames[] = {
33568 (char *) "self",(char *) "validator", NULL
33569 };
33570
33571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33573 if (!SWIG_IsOK(res1)) {
33574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33575 }
33576 arg1 = reinterpret_cast< wxWindow * >(argp1);
33577 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33578 if (!SWIG_IsOK(res2)) {
33579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33580 }
33581 if (!argp2) {
33582 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33583 }
33584 arg2 = reinterpret_cast< wxValidator * >(argp2);
33585 {
33586 PyThreadState* __tstate = wxPyBeginAllowThreads();
33587 (arg1)->SetValidator((wxValidator const &)*arg2);
33588 wxPyEndAllowThreads(__tstate);
33589 if (PyErr_Occurred()) SWIG_fail;
33590 }
33591 resultobj = SWIG_Py_Void();
33592 return resultobj;
33593 fail:
33594 return NULL;
33595 }
33596
33597
33598 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33599 PyObject *resultobj = 0;
33600 wxWindow *arg1 = (wxWindow *) 0 ;
33601 wxValidator *result = 0 ;
33602 void *argp1 = 0 ;
33603 int res1 = 0 ;
33604 PyObject *swig_obj[1] ;
33605
33606 if (!args) SWIG_fail;
33607 swig_obj[0] = args;
33608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33609 if (!SWIG_IsOK(res1)) {
33610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33611 }
33612 arg1 = reinterpret_cast< wxWindow * >(argp1);
33613 {
33614 PyThreadState* __tstate = wxPyBeginAllowThreads();
33615 result = (wxValidator *)(arg1)->GetValidator();
33616 wxPyEndAllowThreads(__tstate);
33617 if (PyErr_Occurred()) SWIG_fail;
33618 }
33619 {
33620 resultobj = wxPyMake_wxObject(result, (bool)0);
33621 }
33622 return resultobj;
33623 fail:
33624 return NULL;
33625 }
33626
33627
33628 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33629 PyObject *resultobj = 0;
33630 wxWindow *arg1 = (wxWindow *) 0 ;
33631 bool result;
33632 void *argp1 = 0 ;
33633 int res1 = 0 ;
33634 PyObject *swig_obj[1] ;
33635
33636 if (!args) SWIG_fail;
33637 swig_obj[0] = args;
33638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33639 if (!SWIG_IsOK(res1)) {
33640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33641 }
33642 arg1 = reinterpret_cast< wxWindow * >(argp1);
33643 {
33644 PyThreadState* __tstate = wxPyBeginAllowThreads();
33645 result = (bool)(arg1)->Validate();
33646 wxPyEndAllowThreads(__tstate);
33647 if (PyErr_Occurred()) SWIG_fail;
33648 }
33649 {
33650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33651 }
33652 return resultobj;
33653 fail:
33654 return NULL;
33655 }
33656
33657
33658 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33659 PyObject *resultobj = 0;
33660 wxWindow *arg1 = (wxWindow *) 0 ;
33661 bool result;
33662 void *argp1 = 0 ;
33663 int res1 = 0 ;
33664 PyObject *swig_obj[1] ;
33665
33666 if (!args) SWIG_fail;
33667 swig_obj[0] = args;
33668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33669 if (!SWIG_IsOK(res1)) {
33670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33671 }
33672 arg1 = reinterpret_cast< wxWindow * >(argp1);
33673 {
33674 PyThreadState* __tstate = wxPyBeginAllowThreads();
33675 result = (bool)(arg1)->TransferDataToWindow();
33676 wxPyEndAllowThreads(__tstate);
33677 if (PyErr_Occurred()) SWIG_fail;
33678 }
33679 {
33680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33681 }
33682 return resultobj;
33683 fail:
33684 return NULL;
33685 }
33686
33687
33688 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33689 PyObject *resultobj = 0;
33690 wxWindow *arg1 = (wxWindow *) 0 ;
33691 bool result;
33692 void *argp1 = 0 ;
33693 int res1 = 0 ;
33694 PyObject *swig_obj[1] ;
33695
33696 if (!args) SWIG_fail;
33697 swig_obj[0] = args;
33698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33699 if (!SWIG_IsOK(res1)) {
33700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33701 }
33702 arg1 = reinterpret_cast< wxWindow * >(argp1);
33703 {
33704 PyThreadState* __tstate = wxPyBeginAllowThreads();
33705 result = (bool)(arg1)->TransferDataFromWindow();
33706 wxPyEndAllowThreads(__tstate);
33707 if (PyErr_Occurred()) SWIG_fail;
33708 }
33709 {
33710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33711 }
33712 return resultobj;
33713 fail:
33714 return NULL;
33715 }
33716
33717
33718 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33719 PyObject *resultobj = 0;
33720 wxWindow *arg1 = (wxWindow *) 0 ;
33721 void *argp1 = 0 ;
33722 int res1 = 0 ;
33723 PyObject *swig_obj[1] ;
33724
33725 if (!args) SWIG_fail;
33726 swig_obj[0] = args;
33727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33728 if (!SWIG_IsOK(res1)) {
33729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33730 }
33731 arg1 = reinterpret_cast< wxWindow * >(argp1);
33732 {
33733 PyThreadState* __tstate = wxPyBeginAllowThreads();
33734 (arg1)->InitDialog();
33735 wxPyEndAllowThreads(__tstate);
33736 if (PyErr_Occurred()) SWIG_fail;
33737 }
33738 resultobj = SWIG_Py_Void();
33739 return resultobj;
33740 fail:
33741 return NULL;
33742 }
33743
33744
33745 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33746 PyObject *resultobj = 0;
33747 wxWindow *arg1 = (wxWindow *) 0 ;
33748 wxAcceleratorTable *arg2 = 0 ;
33749 void *argp1 = 0 ;
33750 int res1 = 0 ;
33751 void *argp2 = 0 ;
33752 int res2 = 0 ;
33753 PyObject * obj0 = 0 ;
33754 PyObject * obj1 = 0 ;
33755 char * kwnames[] = {
33756 (char *) "self",(char *) "accel", NULL
33757 };
33758
33759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33761 if (!SWIG_IsOK(res1)) {
33762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33763 }
33764 arg1 = reinterpret_cast< wxWindow * >(argp1);
33765 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33766 if (!SWIG_IsOK(res2)) {
33767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33768 }
33769 if (!argp2) {
33770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33771 }
33772 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33773 {
33774 PyThreadState* __tstate = wxPyBeginAllowThreads();
33775 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33776 wxPyEndAllowThreads(__tstate);
33777 if (PyErr_Occurred()) SWIG_fail;
33778 }
33779 resultobj = SWIG_Py_Void();
33780 return resultobj;
33781 fail:
33782 return NULL;
33783 }
33784
33785
33786 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33787 PyObject *resultobj = 0;
33788 wxWindow *arg1 = (wxWindow *) 0 ;
33789 wxAcceleratorTable *result = 0 ;
33790 void *argp1 = 0 ;
33791 int res1 = 0 ;
33792 PyObject *swig_obj[1] ;
33793
33794 if (!args) SWIG_fail;
33795 swig_obj[0] = args;
33796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33797 if (!SWIG_IsOK(res1)) {
33798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33799 }
33800 arg1 = reinterpret_cast< wxWindow * >(argp1);
33801 {
33802 PyThreadState* __tstate = wxPyBeginAllowThreads();
33803 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33804 wxPyEndAllowThreads(__tstate);
33805 if (PyErr_Occurred()) SWIG_fail;
33806 }
33807 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33808 return resultobj;
33809 fail:
33810 return NULL;
33811 }
33812
33813
33814 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33815 PyObject *resultobj = 0;
33816 wxWindow *arg1 = (wxWindow *) 0 ;
33817 int arg2 ;
33818 int arg3 ;
33819 int arg4 ;
33820 bool result;
33821 void *argp1 = 0 ;
33822 int res1 = 0 ;
33823 int val2 ;
33824 int ecode2 = 0 ;
33825 int val3 ;
33826 int ecode3 = 0 ;
33827 int val4 ;
33828 int ecode4 = 0 ;
33829 PyObject * obj0 = 0 ;
33830 PyObject * obj1 = 0 ;
33831 PyObject * obj2 = 0 ;
33832 PyObject * obj3 = 0 ;
33833 char * kwnames[] = {
33834 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33835 };
33836
33837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33839 if (!SWIG_IsOK(res1)) {
33840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33841 }
33842 arg1 = reinterpret_cast< wxWindow * >(argp1);
33843 ecode2 = SWIG_AsVal_int(obj1, &val2);
33844 if (!SWIG_IsOK(ecode2)) {
33845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33846 }
33847 arg2 = static_cast< int >(val2);
33848 ecode3 = SWIG_AsVal_int(obj2, &val3);
33849 if (!SWIG_IsOK(ecode3)) {
33850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33851 }
33852 arg3 = static_cast< int >(val3);
33853 ecode4 = SWIG_AsVal_int(obj3, &val4);
33854 if (!SWIG_IsOK(ecode4)) {
33855 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33856 }
33857 arg4 = static_cast< int >(val4);
33858 {
33859 PyThreadState* __tstate = wxPyBeginAllowThreads();
33860 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33861 wxPyEndAllowThreads(__tstate);
33862 if (PyErr_Occurred()) SWIG_fail;
33863 }
33864 {
33865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33866 }
33867 return resultobj;
33868 fail:
33869 return NULL;
33870 }
33871
33872
33873 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33874 PyObject *resultobj = 0;
33875 wxWindow *arg1 = (wxWindow *) 0 ;
33876 int arg2 ;
33877 bool result;
33878 void *argp1 = 0 ;
33879 int res1 = 0 ;
33880 int val2 ;
33881 int ecode2 = 0 ;
33882 PyObject * obj0 = 0 ;
33883 PyObject * obj1 = 0 ;
33884 char * kwnames[] = {
33885 (char *) "self",(char *) "hotkeyId", NULL
33886 };
33887
33888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33890 if (!SWIG_IsOK(res1)) {
33891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33892 }
33893 arg1 = reinterpret_cast< wxWindow * >(argp1);
33894 ecode2 = SWIG_AsVal_int(obj1, &val2);
33895 if (!SWIG_IsOK(ecode2)) {
33896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33897 }
33898 arg2 = static_cast< int >(val2);
33899 {
33900 PyThreadState* __tstate = wxPyBeginAllowThreads();
33901 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33902 wxPyEndAllowThreads(__tstate);
33903 if (PyErr_Occurred()) SWIG_fail;
33904 }
33905 {
33906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33907 }
33908 return resultobj;
33909 fail:
33910 return NULL;
33911 }
33912
33913
33914 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33915 PyObject *resultobj = 0;
33916 wxWindow *arg1 = (wxWindow *) 0 ;
33917 wxPoint *arg2 = 0 ;
33918 wxPoint result;
33919 void *argp1 = 0 ;
33920 int res1 = 0 ;
33921 wxPoint temp2 ;
33922 PyObject * obj0 = 0 ;
33923 PyObject * obj1 = 0 ;
33924 char * kwnames[] = {
33925 (char *) "self",(char *) "pt", NULL
33926 };
33927
33928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33930 if (!SWIG_IsOK(res1)) {
33931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33932 }
33933 arg1 = reinterpret_cast< wxWindow * >(argp1);
33934 {
33935 arg2 = &temp2;
33936 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33937 }
33938 {
33939 PyThreadState* __tstate = wxPyBeginAllowThreads();
33940 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33941 wxPyEndAllowThreads(__tstate);
33942 if (PyErr_Occurred()) SWIG_fail;
33943 }
33944 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33945 return resultobj;
33946 fail:
33947 return NULL;
33948 }
33949
33950
33951 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33952 PyObject *resultobj = 0;
33953 wxWindow *arg1 = (wxWindow *) 0 ;
33954 wxSize *arg2 = 0 ;
33955 wxSize result;
33956 void *argp1 = 0 ;
33957 int res1 = 0 ;
33958 wxSize temp2 ;
33959 PyObject * obj0 = 0 ;
33960 PyObject * obj1 = 0 ;
33961 char * kwnames[] = {
33962 (char *) "self",(char *) "sz", NULL
33963 };
33964
33965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33967 if (!SWIG_IsOK(res1)) {
33968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33969 }
33970 arg1 = reinterpret_cast< wxWindow * >(argp1);
33971 {
33972 arg2 = &temp2;
33973 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33974 }
33975 {
33976 PyThreadState* __tstate = wxPyBeginAllowThreads();
33977 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33978 wxPyEndAllowThreads(__tstate);
33979 if (PyErr_Occurred()) SWIG_fail;
33980 }
33981 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33982 return resultobj;
33983 fail:
33984 return NULL;
33985 }
33986
33987
33988 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33989 PyObject *resultobj = 0;
33990 wxWindow *arg1 = (wxWindow *) 0 ;
33991 wxPoint *arg2 = 0 ;
33992 wxPoint result;
33993 void *argp1 = 0 ;
33994 int res1 = 0 ;
33995 wxPoint temp2 ;
33996 PyObject * obj0 = 0 ;
33997 PyObject * obj1 = 0 ;
33998 char * kwnames[] = {
33999 (char *) "self",(char *) "pt", NULL
34000 };
34001
34002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34004 if (!SWIG_IsOK(res1)) {
34005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34006 }
34007 arg1 = reinterpret_cast< wxWindow * >(argp1);
34008 {
34009 arg2 = &temp2;
34010 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34011 }
34012 {
34013 PyThreadState* __tstate = wxPyBeginAllowThreads();
34014 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34015 wxPyEndAllowThreads(__tstate);
34016 if (PyErr_Occurred()) SWIG_fail;
34017 }
34018 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34019 return resultobj;
34020 fail:
34021 return NULL;
34022 }
34023
34024
34025 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34026 PyObject *resultobj = 0;
34027 wxWindow *arg1 = (wxWindow *) 0 ;
34028 wxSize *arg2 = 0 ;
34029 wxSize result;
34030 void *argp1 = 0 ;
34031 int res1 = 0 ;
34032 wxSize temp2 ;
34033 PyObject * obj0 = 0 ;
34034 PyObject * obj1 = 0 ;
34035 char * kwnames[] = {
34036 (char *) "self",(char *) "sz", NULL
34037 };
34038
34039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34041 if (!SWIG_IsOK(res1)) {
34042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34043 }
34044 arg1 = reinterpret_cast< wxWindow * >(argp1);
34045 {
34046 arg2 = &temp2;
34047 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34048 }
34049 {
34050 PyThreadState* __tstate = wxPyBeginAllowThreads();
34051 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34052 wxPyEndAllowThreads(__tstate);
34053 if (PyErr_Occurred()) SWIG_fail;
34054 }
34055 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34056 return resultobj;
34057 fail:
34058 return NULL;
34059 }
34060
34061
34062 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34063 PyObject *resultobj = 0;
34064 wxWindow *arg1 = (wxWindow *) 0 ;
34065 wxPoint *arg2 = 0 ;
34066 wxPoint result;
34067 void *argp1 = 0 ;
34068 int res1 = 0 ;
34069 wxPoint temp2 ;
34070 PyObject * obj0 = 0 ;
34071 PyObject * obj1 = 0 ;
34072 char * kwnames[] = {
34073 (char *) "self",(char *) "pt", NULL
34074 };
34075
34076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34078 if (!SWIG_IsOK(res1)) {
34079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34080 }
34081 arg1 = reinterpret_cast< wxWindow * >(argp1);
34082 {
34083 arg2 = &temp2;
34084 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34085 }
34086 {
34087 PyThreadState* __tstate = wxPyBeginAllowThreads();
34088 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34089 wxPyEndAllowThreads(__tstate);
34090 if (PyErr_Occurred()) SWIG_fail;
34091 }
34092 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34093 return resultobj;
34094 fail:
34095 return NULL;
34096 }
34097
34098
34099 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34100 PyObject *resultobj = 0;
34101 wxWindow *arg1 = (wxWindow *) 0 ;
34102 wxSize *arg2 = 0 ;
34103 wxSize result;
34104 void *argp1 = 0 ;
34105 int res1 = 0 ;
34106 wxSize temp2 ;
34107 PyObject * obj0 = 0 ;
34108 PyObject * obj1 = 0 ;
34109 char * kwnames[] = {
34110 (char *) "self",(char *) "sz", NULL
34111 };
34112
34113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34115 if (!SWIG_IsOK(res1)) {
34116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34117 }
34118 arg1 = reinterpret_cast< wxWindow * >(argp1);
34119 {
34120 arg2 = &temp2;
34121 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34122 }
34123 {
34124 PyThreadState* __tstate = wxPyBeginAllowThreads();
34125 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34126 wxPyEndAllowThreads(__tstate);
34127 if (PyErr_Occurred()) SWIG_fail;
34128 }
34129 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34130 return resultobj;
34131 fail:
34132 return NULL;
34133 }
34134
34135
34136 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34137 PyObject *resultobj = 0;
34138 wxWindow *arg1 = (wxWindow *) 0 ;
34139 int arg2 ;
34140 int arg3 ;
34141 void *argp1 = 0 ;
34142 int res1 = 0 ;
34143 int val2 ;
34144 int ecode2 = 0 ;
34145 int val3 ;
34146 int ecode3 = 0 ;
34147 PyObject * obj0 = 0 ;
34148 PyObject * obj1 = 0 ;
34149 PyObject * obj2 = 0 ;
34150 char * kwnames[] = {
34151 (char *) "self",(char *) "x",(char *) "y", NULL
34152 };
34153
34154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34156 if (!SWIG_IsOK(res1)) {
34157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34158 }
34159 arg1 = reinterpret_cast< wxWindow * >(argp1);
34160 ecode2 = SWIG_AsVal_int(obj1, &val2);
34161 if (!SWIG_IsOK(ecode2)) {
34162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34163 }
34164 arg2 = static_cast< int >(val2);
34165 ecode3 = SWIG_AsVal_int(obj2, &val3);
34166 if (!SWIG_IsOK(ecode3)) {
34167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34168 }
34169 arg3 = static_cast< int >(val3);
34170 {
34171 PyThreadState* __tstate = wxPyBeginAllowThreads();
34172 (arg1)->WarpPointer(arg2,arg3);
34173 wxPyEndAllowThreads(__tstate);
34174 if (PyErr_Occurred()) SWIG_fail;
34175 }
34176 resultobj = SWIG_Py_Void();
34177 return resultobj;
34178 fail:
34179 return NULL;
34180 }
34181
34182
34183 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34184 PyObject *resultobj = 0;
34185 wxWindow *arg1 = (wxWindow *) 0 ;
34186 void *argp1 = 0 ;
34187 int res1 = 0 ;
34188 PyObject *swig_obj[1] ;
34189
34190 if (!args) SWIG_fail;
34191 swig_obj[0] = args;
34192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34193 if (!SWIG_IsOK(res1)) {
34194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34195 }
34196 arg1 = reinterpret_cast< wxWindow * >(argp1);
34197 {
34198 PyThreadState* __tstate = wxPyBeginAllowThreads();
34199 (arg1)->CaptureMouse();
34200 wxPyEndAllowThreads(__tstate);
34201 if (PyErr_Occurred()) SWIG_fail;
34202 }
34203 resultobj = SWIG_Py_Void();
34204 return resultobj;
34205 fail:
34206 return NULL;
34207 }
34208
34209
34210 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34211 PyObject *resultobj = 0;
34212 wxWindow *arg1 = (wxWindow *) 0 ;
34213 void *argp1 = 0 ;
34214 int res1 = 0 ;
34215 PyObject *swig_obj[1] ;
34216
34217 if (!args) SWIG_fail;
34218 swig_obj[0] = args;
34219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34220 if (!SWIG_IsOK(res1)) {
34221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34222 }
34223 arg1 = reinterpret_cast< wxWindow * >(argp1);
34224 {
34225 PyThreadState* __tstate = wxPyBeginAllowThreads();
34226 (arg1)->ReleaseMouse();
34227 wxPyEndAllowThreads(__tstate);
34228 if (PyErr_Occurred()) SWIG_fail;
34229 }
34230 resultobj = SWIG_Py_Void();
34231 return resultobj;
34232 fail:
34233 return NULL;
34234 }
34235
34236
34237 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34238 PyObject *resultobj = 0;
34239 wxWindow *result = 0 ;
34240
34241 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34242 {
34243 if (!wxPyCheckForApp()) SWIG_fail;
34244 PyThreadState* __tstate = wxPyBeginAllowThreads();
34245 result = (wxWindow *)wxWindow::GetCapture();
34246 wxPyEndAllowThreads(__tstate);
34247 if (PyErr_Occurred()) SWIG_fail;
34248 }
34249 {
34250 resultobj = wxPyMake_wxObject(result, 0);
34251 }
34252 return resultobj;
34253 fail:
34254 return NULL;
34255 }
34256
34257
34258 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34259 PyObject *resultobj = 0;
34260 wxWindow *arg1 = (wxWindow *) 0 ;
34261 bool result;
34262 void *argp1 = 0 ;
34263 int res1 = 0 ;
34264 PyObject *swig_obj[1] ;
34265
34266 if (!args) SWIG_fail;
34267 swig_obj[0] = args;
34268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34269 if (!SWIG_IsOK(res1)) {
34270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34271 }
34272 arg1 = reinterpret_cast< wxWindow * >(argp1);
34273 {
34274 PyThreadState* __tstate = wxPyBeginAllowThreads();
34275 result = (bool)((wxWindow const *)arg1)->HasCapture();
34276 wxPyEndAllowThreads(__tstate);
34277 if (PyErr_Occurred()) SWIG_fail;
34278 }
34279 {
34280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34281 }
34282 return resultobj;
34283 fail:
34284 return NULL;
34285 }
34286
34287
34288 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34289 PyObject *resultobj = 0;
34290 wxWindow *arg1 = (wxWindow *) 0 ;
34291 bool arg2 = (bool) true ;
34292 wxRect *arg3 = (wxRect *) NULL ;
34293 void *argp1 = 0 ;
34294 int res1 = 0 ;
34295 bool val2 ;
34296 int ecode2 = 0 ;
34297 void *argp3 = 0 ;
34298 int res3 = 0 ;
34299 PyObject * obj0 = 0 ;
34300 PyObject * obj1 = 0 ;
34301 PyObject * obj2 = 0 ;
34302 char * kwnames[] = {
34303 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34304 };
34305
34306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34308 if (!SWIG_IsOK(res1)) {
34309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34310 }
34311 arg1 = reinterpret_cast< wxWindow * >(argp1);
34312 if (obj1) {
34313 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34314 if (!SWIG_IsOK(ecode2)) {
34315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34316 }
34317 arg2 = static_cast< bool >(val2);
34318 }
34319 if (obj2) {
34320 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34321 if (!SWIG_IsOK(res3)) {
34322 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34323 }
34324 arg3 = reinterpret_cast< wxRect * >(argp3);
34325 }
34326 {
34327 PyThreadState* __tstate = wxPyBeginAllowThreads();
34328 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34329 wxPyEndAllowThreads(__tstate);
34330 if (PyErr_Occurred()) SWIG_fail;
34331 }
34332 resultobj = SWIG_Py_Void();
34333 return resultobj;
34334 fail:
34335 return NULL;
34336 }
34337
34338
34339 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34340 PyObject *resultobj = 0;
34341 wxWindow *arg1 = (wxWindow *) 0 ;
34342 wxRect *arg2 = 0 ;
34343 bool arg3 = (bool) true ;
34344 void *argp1 = 0 ;
34345 int res1 = 0 ;
34346 wxRect temp2 ;
34347 bool val3 ;
34348 int ecode3 = 0 ;
34349 PyObject * obj0 = 0 ;
34350 PyObject * obj1 = 0 ;
34351 PyObject * obj2 = 0 ;
34352 char * kwnames[] = {
34353 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34354 };
34355
34356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34358 if (!SWIG_IsOK(res1)) {
34359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34360 }
34361 arg1 = reinterpret_cast< wxWindow * >(argp1);
34362 {
34363 arg2 = &temp2;
34364 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34365 }
34366 if (obj2) {
34367 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34368 if (!SWIG_IsOK(ecode3)) {
34369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34370 }
34371 arg3 = static_cast< bool >(val3);
34372 }
34373 {
34374 PyThreadState* __tstate = wxPyBeginAllowThreads();
34375 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34376 wxPyEndAllowThreads(__tstate);
34377 if (PyErr_Occurred()) SWIG_fail;
34378 }
34379 resultobj = SWIG_Py_Void();
34380 return resultobj;
34381 fail:
34382 return NULL;
34383 }
34384
34385
34386 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34387 PyObject *resultobj = 0;
34388 wxWindow *arg1 = (wxWindow *) 0 ;
34389 void *argp1 = 0 ;
34390 int res1 = 0 ;
34391 PyObject *swig_obj[1] ;
34392
34393 if (!args) SWIG_fail;
34394 swig_obj[0] = args;
34395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34396 if (!SWIG_IsOK(res1)) {
34397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34398 }
34399 arg1 = reinterpret_cast< wxWindow * >(argp1);
34400 {
34401 PyThreadState* __tstate = wxPyBeginAllowThreads();
34402 (arg1)->Update();
34403 wxPyEndAllowThreads(__tstate);
34404 if (PyErr_Occurred()) SWIG_fail;
34405 }
34406 resultobj = SWIG_Py_Void();
34407 return resultobj;
34408 fail:
34409 return NULL;
34410 }
34411
34412
34413 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34414 PyObject *resultobj = 0;
34415 wxWindow *arg1 = (wxWindow *) 0 ;
34416 void *argp1 = 0 ;
34417 int res1 = 0 ;
34418 PyObject *swig_obj[1] ;
34419
34420 if (!args) SWIG_fail;
34421 swig_obj[0] = args;
34422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34423 if (!SWIG_IsOK(res1)) {
34424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34425 }
34426 arg1 = reinterpret_cast< wxWindow * >(argp1);
34427 {
34428 PyThreadState* __tstate = wxPyBeginAllowThreads();
34429 (arg1)->ClearBackground();
34430 wxPyEndAllowThreads(__tstate);
34431 if (PyErr_Occurred()) SWIG_fail;
34432 }
34433 resultobj = SWIG_Py_Void();
34434 return resultobj;
34435 fail:
34436 return NULL;
34437 }
34438
34439
34440 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34441 PyObject *resultobj = 0;
34442 wxWindow *arg1 = (wxWindow *) 0 ;
34443 void *argp1 = 0 ;
34444 int res1 = 0 ;
34445 PyObject *swig_obj[1] ;
34446
34447 if (!args) SWIG_fail;
34448 swig_obj[0] = args;
34449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34450 if (!SWIG_IsOK(res1)) {
34451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34452 }
34453 arg1 = reinterpret_cast< wxWindow * >(argp1);
34454 {
34455 PyThreadState* __tstate = wxPyBeginAllowThreads();
34456 (arg1)->Freeze();
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_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34468 PyObject *resultobj = 0;
34469 wxWindow *arg1 = (wxWindow *) 0 ;
34470 void *argp1 = 0 ;
34471 int res1 = 0 ;
34472 PyObject *swig_obj[1] ;
34473
34474 if (!args) SWIG_fail;
34475 swig_obj[0] = args;
34476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34477 if (!SWIG_IsOK(res1)) {
34478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34479 }
34480 arg1 = reinterpret_cast< wxWindow * >(argp1);
34481 {
34482 PyThreadState* __tstate = wxPyBeginAllowThreads();
34483 (arg1)->Thaw();
34484 wxPyEndAllowThreads(__tstate);
34485 if (PyErr_Occurred()) SWIG_fail;
34486 }
34487 resultobj = SWIG_Py_Void();
34488 return resultobj;
34489 fail:
34490 return NULL;
34491 }
34492
34493
34494 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34495 PyObject *resultobj = 0;
34496 wxWindow *arg1 = (wxWindow *) 0 ;
34497 wxDC *arg2 = 0 ;
34498 void *argp1 = 0 ;
34499 int res1 = 0 ;
34500 void *argp2 = 0 ;
34501 int res2 = 0 ;
34502 PyObject * obj0 = 0 ;
34503 PyObject * obj1 = 0 ;
34504 char * kwnames[] = {
34505 (char *) "self",(char *) "dc", NULL
34506 };
34507
34508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34510 if (!SWIG_IsOK(res1)) {
34511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34512 }
34513 arg1 = reinterpret_cast< wxWindow * >(argp1);
34514 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34515 if (!SWIG_IsOK(res2)) {
34516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34517 }
34518 if (!argp2) {
34519 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34520 }
34521 arg2 = reinterpret_cast< wxDC * >(argp2);
34522 {
34523 PyThreadState* __tstate = wxPyBeginAllowThreads();
34524 (arg1)->PrepareDC(*arg2);
34525 wxPyEndAllowThreads(__tstate);
34526 if (PyErr_Occurred()) SWIG_fail;
34527 }
34528 resultobj = SWIG_Py_Void();
34529 return resultobj;
34530 fail:
34531 return NULL;
34532 }
34533
34534
34535 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34536 PyObject *resultobj = 0;
34537 wxWindow *arg1 = (wxWindow *) 0 ;
34538 wxRegion *result = 0 ;
34539 void *argp1 = 0 ;
34540 int res1 = 0 ;
34541 PyObject *swig_obj[1] ;
34542
34543 if (!args) SWIG_fail;
34544 swig_obj[0] = args;
34545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34546 if (!SWIG_IsOK(res1)) {
34547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34548 }
34549 arg1 = reinterpret_cast< wxWindow * >(argp1);
34550 {
34551 PyThreadState* __tstate = wxPyBeginAllowThreads();
34552 {
34553 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34554 result = (wxRegion *) &_result_ref;
34555 }
34556 wxPyEndAllowThreads(__tstate);
34557 if (PyErr_Occurred()) SWIG_fail;
34558 }
34559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34560 return resultobj;
34561 fail:
34562 return NULL;
34563 }
34564
34565
34566 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34567 PyObject *resultobj = 0;
34568 wxWindow *arg1 = (wxWindow *) 0 ;
34569 wxRect result;
34570 void *argp1 = 0 ;
34571 int res1 = 0 ;
34572 PyObject *swig_obj[1] ;
34573
34574 if (!args) SWIG_fail;
34575 swig_obj[0] = args;
34576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34577 if (!SWIG_IsOK(res1)) {
34578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34579 }
34580 arg1 = reinterpret_cast< wxWindow * >(argp1);
34581 {
34582 PyThreadState* __tstate = wxPyBeginAllowThreads();
34583 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34584 wxPyEndAllowThreads(__tstate);
34585 if (PyErr_Occurred()) SWIG_fail;
34586 }
34587 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34588 return resultobj;
34589 fail:
34590 return NULL;
34591 }
34592
34593
34594 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34595 PyObject *resultobj = 0;
34596 wxWindow *arg1 = (wxWindow *) 0 ;
34597 int arg2 ;
34598 int arg3 ;
34599 int arg4 = (int) 1 ;
34600 int arg5 = (int) 1 ;
34601 bool result;
34602 void *argp1 = 0 ;
34603 int res1 = 0 ;
34604 int val2 ;
34605 int ecode2 = 0 ;
34606 int val3 ;
34607 int ecode3 = 0 ;
34608 int val4 ;
34609 int ecode4 = 0 ;
34610 int val5 ;
34611 int ecode5 = 0 ;
34612 PyObject * obj0 = 0 ;
34613 PyObject * obj1 = 0 ;
34614 PyObject * obj2 = 0 ;
34615 PyObject * obj3 = 0 ;
34616 PyObject * obj4 = 0 ;
34617 char * kwnames[] = {
34618 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34619 };
34620
34621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34623 if (!SWIG_IsOK(res1)) {
34624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34625 }
34626 arg1 = reinterpret_cast< wxWindow * >(argp1);
34627 ecode2 = SWIG_AsVal_int(obj1, &val2);
34628 if (!SWIG_IsOK(ecode2)) {
34629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34630 }
34631 arg2 = static_cast< int >(val2);
34632 ecode3 = SWIG_AsVal_int(obj2, &val3);
34633 if (!SWIG_IsOK(ecode3)) {
34634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34635 }
34636 arg3 = static_cast< int >(val3);
34637 if (obj3) {
34638 ecode4 = SWIG_AsVal_int(obj3, &val4);
34639 if (!SWIG_IsOK(ecode4)) {
34640 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34641 }
34642 arg4 = static_cast< int >(val4);
34643 }
34644 if (obj4) {
34645 ecode5 = SWIG_AsVal_int(obj4, &val5);
34646 if (!SWIG_IsOK(ecode5)) {
34647 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34648 }
34649 arg5 = static_cast< int >(val5);
34650 }
34651 {
34652 PyThreadState* __tstate = wxPyBeginAllowThreads();
34653 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34654 wxPyEndAllowThreads(__tstate);
34655 if (PyErr_Occurred()) SWIG_fail;
34656 }
34657 {
34658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34659 }
34660 return resultobj;
34661 fail:
34662 return NULL;
34663 }
34664
34665
34666 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34667 PyObject *resultobj = 0;
34668 wxWindow *arg1 = (wxWindow *) 0 ;
34669 wxPoint *arg2 = 0 ;
34670 bool result;
34671 void *argp1 = 0 ;
34672 int res1 = 0 ;
34673 wxPoint temp2 ;
34674 PyObject * obj0 = 0 ;
34675 PyObject * obj1 = 0 ;
34676 char * kwnames[] = {
34677 (char *) "self",(char *) "pt", NULL
34678 };
34679
34680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34682 if (!SWIG_IsOK(res1)) {
34683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34684 }
34685 arg1 = reinterpret_cast< wxWindow * >(argp1);
34686 {
34687 arg2 = &temp2;
34688 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34689 }
34690 {
34691 PyThreadState* __tstate = wxPyBeginAllowThreads();
34692 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34693 wxPyEndAllowThreads(__tstate);
34694 if (PyErr_Occurred()) SWIG_fail;
34695 }
34696 {
34697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34698 }
34699 return resultobj;
34700 fail:
34701 return NULL;
34702 }
34703
34704
34705 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34706 PyObject *resultobj = 0;
34707 wxWindow *arg1 = (wxWindow *) 0 ;
34708 wxRect *arg2 = 0 ;
34709 bool result;
34710 void *argp1 = 0 ;
34711 int res1 = 0 ;
34712 wxRect temp2 ;
34713 PyObject * obj0 = 0 ;
34714 PyObject * obj1 = 0 ;
34715 char * kwnames[] = {
34716 (char *) "self",(char *) "rect", NULL
34717 };
34718
34719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34721 if (!SWIG_IsOK(res1)) {
34722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34723 }
34724 arg1 = reinterpret_cast< wxWindow * >(argp1);
34725 {
34726 arg2 = &temp2;
34727 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34728 }
34729 {
34730 PyThreadState* __tstate = wxPyBeginAllowThreads();
34731 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34732 wxPyEndAllowThreads(__tstate);
34733 if (PyErr_Occurred()) SWIG_fail;
34734 }
34735 {
34736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34737 }
34738 return resultobj;
34739 fail:
34740 return NULL;
34741 }
34742
34743
34744 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34745 PyObject *resultobj = 0;
34746 wxWindow *arg1 = (wxWindow *) 0 ;
34747 SwigValueWrapper<wxVisualAttributes > result;
34748 void *argp1 = 0 ;
34749 int res1 = 0 ;
34750 PyObject *swig_obj[1] ;
34751
34752 if (!args) SWIG_fail;
34753 swig_obj[0] = args;
34754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34755 if (!SWIG_IsOK(res1)) {
34756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34757 }
34758 arg1 = reinterpret_cast< wxWindow * >(argp1);
34759 {
34760 PyThreadState* __tstate = wxPyBeginAllowThreads();
34761 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34762 wxPyEndAllowThreads(__tstate);
34763 if (PyErr_Occurred()) SWIG_fail;
34764 }
34765 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34766 return resultobj;
34767 fail:
34768 return NULL;
34769 }
34770
34771
34772 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34773 PyObject *resultobj = 0;
34774 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34775 SwigValueWrapper<wxVisualAttributes > result;
34776 int val1 ;
34777 int ecode1 = 0 ;
34778 PyObject * obj0 = 0 ;
34779 char * kwnames[] = {
34780 (char *) "variant", NULL
34781 };
34782
34783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34784 if (obj0) {
34785 ecode1 = SWIG_AsVal_int(obj0, &val1);
34786 if (!SWIG_IsOK(ecode1)) {
34787 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34788 }
34789 arg1 = static_cast< wxWindowVariant >(val1);
34790 }
34791 {
34792 if (!wxPyCheckForApp()) SWIG_fail;
34793 PyThreadState* __tstate = wxPyBeginAllowThreads();
34794 result = wxWindow::GetClassDefaultAttributes(arg1);
34795 wxPyEndAllowThreads(__tstate);
34796 if (PyErr_Occurred()) SWIG_fail;
34797 }
34798 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34799 return resultobj;
34800 fail:
34801 return NULL;
34802 }
34803
34804
34805 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34806 PyObject *resultobj = 0;
34807 wxWindow *arg1 = (wxWindow *) 0 ;
34808 wxColour *arg2 = 0 ;
34809 bool result;
34810 void *argp1 = 0 ;
34811 int res1 = 0 ;
34812 wxColour temp2 ;
34813 PyObject * obj0 = 0 ;
34814 PyObject * obj1 = 0 ;
34815 char * kwnames[] = {
34816 (char *) "self",(char *) "colour", NULL
34817 };
34818
34819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34821 if (!SWIG_IsOK(res1)) {
34822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34823 }
34824 arg1 = reinterpret_cast< wxWindow * >(argp1);
34825 {
34826 arg2 = &temp2;
34827 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34828 }
34829 {
34830 PyThreadState* __tstate = wxPyBeginAllowThreads();
34831 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34832 wxPyEndAllowThreads(__tstate);
34833 if (PyErr_Occurred()) SWIG_fail;
34834 }
34835 {
34836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34837 }
34838 return resultobj;
34839 fail:
34840 return NULL;
34841 }
34842
34843
34844 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34845 PyObject *resultobj = 0;
34846 wxWindow *arg1 = (wxWindow *) 0 ;
34847 wxColour *arg2 = 0 ;
34848 void *argp1 = 0 ;
34849 int res1 = 0 ;
34850 wxColour temp2 ;
34851 PyObject * obj0 = 0 ;
34852 PyObject * obj1 = 0 ;
34853 char * kwnames[] = {
34854 (char *) "self",(char *) "colour", NULL
34855 };
34856
34857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34859 if (!SWIG_IsOK(res1)) {
34860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34861 }
34862 arg1 = reinterpret_cast< wxWindow * >(argp1);
34863 {
34864 arg2 = &temp2;
34865 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34866 }
34867 {
34868 PyThreadState* __tstate = wxPyBeginAllowThreads();
34869 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34870 wxPyEndAllowThreads(__tstate);
34871 if (PyErr_Occurred()) SWIG_fail;
34872 }
34873 resultobj = SWIG_Py_Void();
34874 return resultobj;
34875 fail:
34876 return NULL;
34877 }
34878
34879
34880 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34881 PyObject *resultobj = 0;
34882 wxWindow *arg1 = (wxWindow *) 0 ;
34883 wxColour *arg2 = 0 ;
34884 bool result;
34885 void *argp1 = 0 ;
34886 int res1 = 0 ;
34887 wxColour temp2 ;
34888 PyObject * obj0 = 0 ;
34889 PyObject * obj1 = 0 ;
34890 char * kwnames[] = {
34891 (char *) "self",(char *) "colour", NULL
34892 };
34893
34894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34896 if (!SWIG_IsOK(res1)) {
34897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34898 }
34899 arg1 = reinterpret_cast< wxWindow * >(argp1);
34900 {
34901 arg2 = &temp2;
34902 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34903 }
34904 {
34905 PyThreadState* __tstate = wxPyBeginAllowThreads();
34906 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34907 wxPyEndAllowThreads(__tstate);
34908 if (PyErr_Occurred()) SWIG_fail;
34909 }
34910 {
34911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34912 }
34913 return resultobj;
34914 fail:
34915 return NULL;
34916 }
34917
34918
34919 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34920 PyObject *resultobj = 0;
34921 wxWindow *arg1 = (wxWindow *) 0 ;
34922 wxColour *arg2 = 0 ;
34923 void *argp1 = 0 ;
34924 int res1 = 0 ;
34925 wxColour temp2 ;
34926 PyObject * obj0 = 0 ;
34927 PyObject * obj1 = 0 ;
34928 char * kwnames[] = {
34929 (char *) "self",(char *) "colour", NULL
34930 };
34931
34932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34934 if (!SWIG_IsOK(res1)) {
34935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34936 }
34937 arg1 = reinterpret_cast< wxWindow * >(argp1);
34938 {
34939 arg2 = &temp2;
34940 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34941 }
34942 {
34943 PyThreadState* __tstate = wxPyBeginAllowThreads();
34944 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34945 wxPyEndAllowThreads(__tstate);
34946 if (PyErr_Occurred()) SWIG_fail;
34947 }
34948 resultobj = SWIG_Py_Void();
34949 return resultobj;
34950 fail:
34951 return NULL;
34952 }
34953
34954
34955 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34956 PyObject *resultobj = 0;
34957 wxWindow *arg1 = (wxWindow *) 0 ;
34958 wxColour result;
34959 void *argp1 = 0 ;
34960 int res1 = 0 ;
34961 PyObject *swig_obj[1] ;
34962
34963 if (!args) SWIG_fail;
34964 swig_obj[0] = args;
34965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34966 if (!SWIG_IsOK(res1)) {
34967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34968 }
34969 arg1 = reinterpret_cast< wxWindow * >(argp1);
34970 {
34971 PyThreadState* __tstate = wxPyBeginAllowThreads();
34972 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34973 wxPyEndAllowThreads(__tstate);
34974 if (PyErr_Occurred()) SWIG_fail;
34975 }
34976 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34977 return resultobj;
34978 fail:
34979 return NULL;
34980 }
34981
34982
34983 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34984 PyObject *resultobj = 0;
34985 wxWindow *arg1 = (wxWindow *) 0 ;
34986 wxColour result;
34987 void *argp1 = 0 ;
34988 int res1 = 0 ;
34989 PyObject *swig_obj[1] ;
34990
34991 if (!args) SWIG_fail;
34992 swig_obj[0] = args;
34993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34994 if (!SWIG_IsOK(res1)) {
34995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34996 }
34997 arg1 = reinterpret_cast< wxWindow * >(argp1);
34998 {
34999 PyThreadState* __tstate = wxPyBeginAllowThreads();
35000 result = ((wxWindow const *)arg1)->GetForegroundColour();
35001 wxPyEndAllowThreads(__tstate);
35002 if (PyErr_Occurred()) SWIG_fail;
35003 }
35004 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35005 return resultobj;
35006 fail:
35007 return NULL;
35008 }
35009
35010
35011 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35012 PyObject *resultobj = 0;
35013 wxWindow *arg1 = (wxWindow *) 0 ;
35014 bool result;
35015 void *argp1 = 0 ;
35016 int res1 = 0 ;
35017 PyObject *swig_obj[1] ;
35018
35019 if (!args) SWIG_fail;
35020 swig_obj[0] = args;
35021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35022 if (!SWIG_IsOK(res1)) {
35023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35024 }
35025 arg1 = reinterpret_cast< wxWindow * >(argp1);
35026 {
35027 PyThreadState* __tstate = wxPyBeginAllowThreads();
35028 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35029 wxPyEndAllowThreads(__tstate);
35030 if (PyErr_Occurred()) SWIG_fail;
35031 }
35032 {
35033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35034 }
35035 return resultobj;
35036 fail:
35037 return NULL;
35038 }
35039
35040
35041 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35042 PyObject *resultobj = 0;
35043 wxWindow *arg1 = (wxWindow *) 0 ;
35044 bool result;
35045 void *argp1 = 0 ;
35046 int res1 = 0 ;
35047 PyObject *swig_obj[1] ;
35048
35049 if (!args) SWIG_fail;
35050 swig_obj[0] = args;
35051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35052 if (!SWIG_IsOK(res1)) {
35053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35054 }
35055 arg1 = reinterpret_cast< wxWindow * >(argp1);
35056 {
35057 PyThreadState* __tstate = wxPyBeginAllowThreads();
35058 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35059 wxPyEndAllowThreads(__tstate);
35060 if (PyErr_Occurred()) SWIG_fail;
35061 }
35062 {
35063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35064 }
35065 return resultobj;
35066 fail:
35067 return NULL;
35068 }
35069
35070
35071 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35072 PyObject *resultobj = 0;
35073 wxWindow *arg1 = (wxWindow *) 0 ;
35074 wxBackgroundStyle arg2 ;
35075 bool result;
35076 void *argp1 = 0 ;
35077 int res1 = 0 ;
35078 int val2 ;
35079 int ecode2 = 0 ;
35080 PyObject * obj0 = 0 ;
35081 PyObject * obj1 = 0 ;
35082 char * kwnames[] = {
35083 (char *) "self",(char *) "style", NULL
35084 };
35085
35086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35088 if (!SWIG_IsOK(res1)) {
35089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35090 }
35091 arg1 = reinterpret_cast< wxWindow * >(argp1);
35092 ecode2 = SWIG_AsVal_int(obj1, &val2);
35093 if (!SWIG_IsOK(ecode2)) {
35094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35095 }
35096 arg2 = static_cast< wxBackgroundStyle >(val2);
35097 {
35098 PyThreadState* __tstate = wxPyBeginAllowThreads();
35099 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35100 wxPyEndAllowThreads(__tstate);
35101 if (PyErr_Occurred()) SWIG_fail;
35102 }
35103 {
35104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35105 }
35106 return resultobj;
35107 fail:
35108 return NULL;
35109 }
35110
35111
35112 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35113 PyObject *resultobj = 0;
35114 wxWindow *arg1 = (wxWindow *) 0 ;
35115 wxBackgroundStyle result;
35116 void *argp1 = 0 ;
35117 int res1 = 0 ;
35118 PyObject *swig_obj[1] ;
35119
35120 if (!args) SWIG_fail;
35121 swig_obj[0] = args;
35122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35123 if (!SWIG_IsOK(res1)) {
35124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35125 }
35126 arg1 = reinterpret_cast< wxWindow * >(argp1);
35127 {
35128 PyThreadState* __tstate = wxPyBeginAllowThreads();
35129 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35130 wxPyEndAllowThreads(__tstate);
35131 if (PyErr_Occurred()) SWIG_fail;
35132 }
35133 resultobj = SWIG_From_int(static_cast< int >(result));
35134 return resultobj;
35135 fail:
35136 return NULL;
35137 }
35138
35139
35140 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35141 PyObject *resultobj = 0;
35142 wxWindow *arg1 = (wxWindow *) 0 ;
35143 bool result;
35144 void *argp1 = 0 ;
35145 int res1 = 0 ;
35146 PyObject *swig_obj[1] ;
35147
35148 if (!args) SWIG_fail;
35149 swig_obj[0] = args;
35150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35151 if (!SWIG_IsOK(res1)) {
35152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35153 }
35154 arg1 = reinterpret_cast< wxWindow * >(argp1);
35155 {
35156 PyThreadState* __tstate = wxPyBeginAllowThreads();
35157 result = (bool)(arg1)->HasTransparentBackground();
35158 wxPyEndAllowThreads(__tstate);
35159 if (PyErr_Occurred()) SWIG_fail;
35160 }
35161 {
35162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35163 }
35164 return resultobj;
35165 fail:
35166 return NULL;
35167 }
35168
35169
35170 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35171 PyObject *resultobj = 0;
35172 wxWindow *arg1 = (wxWindow *) 0 ;
35173 wxCursor *arg2 = 0 ;
35174 bool result;
35175 void *argp1 = 0 ;
35176 int res1 = 0 ;
35177 void *argp2 = 0 ;
35178 int res2 = 0 ;
35179 PyObject * obj0 = 0 ;
35180 PyObject * obj1 = 0 ;
35181 char * kwnames[] = {
35182 (char *) "self",(char *) "cursor", NULL
35183 };
35184
35185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35187 if (!SWIG_IsOK(res1)) {
35188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35189 }
35190 arg1 = reinterpret_cast< wxWindow * >(argp1);
35191 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35192 if (!SWIG_IsOK(res2)) {
35193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35194 }
35195 if (!argp2) {
35196 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35197 }
35198 arg2 = reinterpret_cast< wxCursor * >(argp2);
35199 {
35200 PyThreadState* __tstate = wxPyBeginAllowThreads();
35201 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35202 wxPyEndAllowThreads(__tstate);
35203 if (PyErr_Occurred()) SWIG_fail;
35204 }
35205 {
35206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35207 }
35208 return resultobj;
35209 fail:
35210 return NULL;
35211 }
35212
35213
35214 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35215 PyObject *resultobj = 0;
35216 wxWindow *arg1 = (wxWindow *) 0 ;
35217 wxCursor result;
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_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35227 }
35228 arg1 = reinterpret_cast< wxWindow * >(argp1);
35229 {
35230 PyThreadState* __tstate = wxPyBeginAllowThreads();
35231 result = (arg1)->GetCursor();
35232 wxPyEndAllowThreads(__tstate);
35233 if (PyErr_Occurred()) SWIG_fail;
35234 }
35235 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35236 return resultobj;
35237 fail:
35238 return NULL;
35239 }
35240
35241
35242 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35243 PyObject *resultobj = 0;
35244 wxWindow *arg1 = (wxWindow *) 0 ;
35245 wxFont *arg2 = 0 ;
35246 bool result;
35247 void *argp1 = 0 ;
35248 int res1 = 0 ;
35249 void *argp2 = 0 ;
35250 int res2 = 0 ;
35251 PyObject * obj0 = 0 ;
35252 PyObject * obj1 = 0 ;
35253 char * kwnames[] = {
35254 (char *) "self",(char *) "font", NULL
35255 };
35256
35257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35259 if (!SWIG_IsOK(res1)) {
35260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35261 }
35262 arg1 = reinterpret_cast< wxWindow * >(argp1);
35263 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35264 if (!SWIG_IsOK(res2)) {
35265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35266 }
35267 if (!argp2) {
35268 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35269 }
35270 arg2 = reinterpret_cast< wxFont * >(argp2);
35271 {
35272 PyThreadState* __tstate = wxPyBeginAllowThreads();
35273 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35274 wxPyEndAllowThreads(__tstate);
35275 if (PyErr_Occurred()) SWIG_fail;
35276 }
35277 {
35278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35279 }
35280 return resultobj;
35281 fail:
35282 return NULL;
35283 }
35284
35285
35286 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35287 PyObject *resultobj = 0;
35288 wxWindow *arg1 = (wxWindow *) 0 ;
35289 wxFont *arg2 = 0 ;
35290 void *argp1 = 0 ;
35291 int res1 = 0 ;
35292 void *argp2 = 0 ;
35293 int res2 = 0 ;
35294 PyObject * obj0 = 0 ;
35295 PyObject * obj1 = 0 ;
35296 char * kwnames[] = {
35297 (char *) "self",(char *) "font", NULL
35298 };
35299
35300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35302 if (!SWIG_IsOK(res1)) {
35303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35304 }
35305 arg1 = reinterpret_cast< wxWindow * >(argp1);
35306 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35307 if (!SWIG_IsOK(res2)) {
35308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35309 }
35310 if (!argp2) {
35311 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35312 }
35313 arg2 = reinterpret_cast< wxFont * >(argp2);
35314 {
35315 PyThreadState* __tstate = wxPyBeginAllowThreads();
35316 (arg1)->SetOwnFont((wxFont const &)*arg2);
35317 wxPyEndAllowThreads(__tstate);
35318 if (PyErr_Occurred()) SWIG_fail;
35319 }
35320 resultobj = SWIG_Py_Void();
35321 return resultobj;
35322 fail:
35323 return NULL;
35324 }
35325
35326
35327 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35328 PyObject *resultobj = 0;
35329 wxWindow *arg1 = (wxWindow *) 0 ;
35330 wxFont result;
35331 void *argp1 = 0 ;
35332 int res1 = 0 ;
35333 PyObject *swig_obj[1] ;
35334
35335 if (!args) SWIG_fail;
35336 swig_obj[0] = args;
35337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35338 if (!SWIG_IsOK(res1)) {
35339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35340 }
35341 arg1 = reinterpret_cast< wxWindow * >(argp1);
35342 {
35343 PyThreadState* __tstate = wxPyBeginAllowThreads();
35344 result = (arg1)->GetFont();
35345 wxPyEndAllowThreads(__tstate);
35346 if (PyErr_Occurred()) SWIG_fail;
35347 }
35348 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35349 return resultobj;
35350 fail:
35351 return NULL;
35352 }
35353
35354
35355 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35356 PyObject *resultobj = 0;
35357 wxWindow *arg1 = (wxWindow *) 0 ;
35358 wxCaret *arg2 = (wxCaret *) 0 ;
35359 void *argp1 = 0 ;
35360 int res1 = 0 ;
35361 int res2 = 0 ;
35362 PyObject * obj0 = 0 ;
35363 PyObject * obj1 = 0 ;
35364 char * kwnames[] = {
35365 (char *) "self",(char *) "caret", NULL
35366 };
35367
35368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35370 if (!SWIG_IsOK(res1)) {
35371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35372 }
35373 arg1 = reinterpret_cast< wxWindow * >(argp1);
35374 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35375 if (!SWIG_IsOK(res2)) {
35376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35377 }
35378 {
35379 PyThreadState* __tstate = wxPyBeginAllowThreads();
35380 (arg1)->SetCaret(arg2);
35381 wxPyEndAllowThreads(__tstate);
35382 if (PyErr_Occurred()) SWIG_fail;
35383 }
35384 resultobj = SWIG_Py_Void();
35385 return resultobj;
35386 fail:
35387 return NULL;
35388 }
35389
35390
35391 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35392 PyObject *resultobj = 0;
35393 wxWindow *arg1 = (wxWindow *) 0 ;
35394 wxCaret *result = 0 ;
35395 void *argp1 = 0 ;
35396 int res1 = 0 ;
35397 PyObject *swig_obj[1] ;
35398
35399 if (!args) SWIG_fail;
35400 swig_obj[0] = args;
35401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35402 if (!SWIG_IsOK(res1)) {
35403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35404 }
35405 arg1 = reinterpret_cast< wxWindow * >(argp1);
35406 {
35407 PyThreadState* __tstate = wxPyBeginAllowThreads();
35408 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35409 wxPyEndAllowThreads(__tstate);
35410 if (PyErr_Occurred()) SWIG_fail;
35411 }
35412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35413 return resultobj;
35414 fail:
35415 return NULL;
35416 }
35417
35418
35419 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35420 PyObject *resultobj = 0;
35421 wxWindow *arg1 = (wxWindow *) 0 ;
35422 int result;
35423 void *argp1 = 0 ;
35424 int res1 = 0 ;
35425 PyObject *swig_obj[1] ;
35426
35427 if (!args) SWIG_fail;
35428 swig_obj[0] = args;
35429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35430 if (!SWIG_IsOK(res1)) {
35431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35432 }
35433 arg1 = reinterpret_cast< wxWindow * >(argp1);
35434 {
35435 PyThreadState* __tstate = wxPyBeginAllowThreads();
35436 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35437 wxPyEndAllowThreads(__tstate);
35438 if (PyErr_Occurred()) SWIG_fail;
35439 }
35440 resultobj = SWIG_From_int(static_cast< int >(result));
35441 return resultobj;
35442 fail:
35443 return NULL;
35444 }
35445
35446
35447 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35448 PyObject *resultobj = 0;
35449 wxWindow *arg1 = (wxWindow *) 0 ;
35450 int result;
35451 void *argp1 = 0 ;
35452 int res1 = 0 ;
35453 PyObject *swig_obj[1] ;
35454
35455 if (!args) SWIG_fail;
35456 swig_obj[0] = args;
35457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35458 if (!SWIG_IsOK(res1)) {
35459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35460 }
35461 arg1 = reinterpret_cast< wxWindow * >(argp1);
35462 {
35463 PyThreadState* __tstate = wxPyBeginAllowThreads();
35464 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35465 wxPyEndAllowThreads(__tstate);
35466 if (PyErr_Occurred()) SWIG_fail;
35467 }
35468 resultobj = SWIG_From_int(static_cast< int >(result));
35469 return resultobj;
35470 fail:
35471 return NULL;
35472 }
35473
35474
35475 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35476 PyObject *resultobj = 0;
35477 wxWindow *arg1 = (wxWindow *) 0 ;
35478 wxString *arg2 = 0 ;
35479 int *arg3 = (int *) 0 ;
35480 int *arg4 = (int *) 0 ;
35481 void *argp1 = 0 ;
35482 int res1 = 0 ;
35483 bool temp2 = false ;
35484 int temp3 ;
35485 int res3 = SWIG_TMPOBJ ;
35486 int temp4 ;
35487 int res4 = SWIG_TMPOBJ ;
35488 PyObject * obj0 = 0 ;
35489 PyObject * obj1 = 0 ;
35490 char * kwnames[] = {
35491 (char *) "self",(char *) "string", NULL
35492 };
35493
35494 arg3 = &temp3;
35495 arg4 = &temp4;
35496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35498 if (!SWIG_IsOK(res1)) {
35499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35500 }
35501 arg1 = reinterpret_cast< wxWindow * >(argp1);
35502 {
35503 arg2 = wxString_in_helper(obj1);
35504 if (arg2 == NULL) SWIG_fail;
35505 temp2 = true;
35506 }
35507 {
35508 PyThreadState* __tstate = wxPyBeginAllowThreads();
35509 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35510 wxPyEndAllowThreads(__tstate);
35511 if (PyErr_Occurred()) SWIG_fail;
35512 }
35513 resultobj = SWIG_Py_Void();
35514 if (SWIG_IsTmpObj(res3)) {
35515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35516 } else {
35517 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35519 }
35520 if (SWIG_IsTmpObj(res4)) {
35521 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35522 } else {
35523 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35524 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35525 }
35526 {
35527 if (temp2)
35528 delete arg2;
35529 }
35530 return resultobj;
35531 fail:
35532 {
35533 if (temp2)
35534 delete arg2;
35535 }
35536 return NULL;
35537 }
35538
35539
35540 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35541 PyObject *resultobj = 0;
35542 wxWindow *arg1 = (wxWindow *) 0 ;
35543 wxString *arg2 = 0 ;
35544 int *arg3 = (int *) 0 ;
35545 int *arg4 = (int *) 0 ;
35546 int *arg5 = (int *) 0 ;
35547 int *arg6 = (int *) 0 ;
35548 wxFont *arg7 = (wxFont *) NULL ;
35549 void *argp1 = 0 ;
35550 int res1 = 0 ;
35551 bool temp2 = false ;
35552 int temp3 ;
35553 int res3 = SWIG_TMPOBJ ;
35554 int temp4 ;
35555 int res4 = SWIG_TMPOBJ ;
35556 int temp5 ;
35557 int res5 = SWIG_TMPOBJ ;
35558 int temp6 ;
35559 int res6 = SWIG_TMPOBJ ;
35560 void *argp7 = 0 ;
35561 int res7 = 0 ;
35562 PyObject * obj0 = 0 ;
35563 PyObject * obj1 = 0 ;
35564 PyObject * obj2 = 0 ;
35565 char * kwnames[] = {
35566 (char *) "self",(char *) "string",(char *) "font", NULL
35567 };
35568
35569 arg3 = &temp3;
35570 arg4 = &temp4;
35571 arg5 = &temp5;
35572 arg6 = &temp6;
35573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35575 if (!SWIG_IsOK(res1)) {
35576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35577 }
35578 arg1 = reinterpret_cast< wxWindow * >(argp1);
35579 {
35580 arg2 = wxString_in_helper(obj1);
35581 if (arg2 == NULL) SWIG_fail;
35582 temp2 = true;
35583 }
35584 if (obj2) {
35585 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35586 if (!SWIG_IsOK(res7)) {
35587 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35588 }
35589 arg7 = reinterpret_cast< wxFont * >(argp7);
35590 }
35591 {
35592 PyThreadState* __tstate = wxPyBeginAllowThreads();
35593 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35594 wxPyEndAllowThreads(__tstate);
35595 if (PyErr_Occurred()) SWIG_fail;
35596 }
35597 resultobj = SWIG_Py_Void();
35598 if (SWIG_IsTmpObj(res3)) {
35599 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35600 } else {
35601 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35602 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35603 }
35604 if (SWIG_IsTmpObj(res4)) {
35605 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35606 } else {
35607 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35608 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35609 }
35610 if (SWIG_IsTmpObj(res5)) {
35611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35612 } else {
35613 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35615 }
35616 if (SWIG_IsTmpObj(res6)) {
35617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35618 } else {
35619 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35621 }
35622 {
35623 if (temp2)
35624 delete arg2;
35625 }
35626 return resultobj;
35627 fail:
35628 {
35629 if (temp2)
35630 delete arg2;
35631 }
35632 return NULL;
35633 }
35634
35635
35636 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35637 PyObject *resultobj = 0;
35638 wxWindow *arg1 = (wxWindow *) 0 ;
35639 int *arg2 = (int *) 0 ;
35640 int *arg3 = (int *) 0 ;
35641 void *argp1 = 0 ;
35642 int res1 = 0 ;
35643 int temp2 ;
35644 int res2 = 0 ;
35645 int temp3 ;
35646 int res3 = 0 ;
35647 PyObject * obj0 = 0 ;
35648 PyObject * obj1 = 0 ;
35649 PyObject * obj2 = 0 ;
35650 char * kwnames[] = {
35651 (char *) "self",(char *) "x",(char *) "y", NULL
35652 };
35653
35654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35656 if (!SWIG_IsOK(res1)) {
35657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35658 }
35659 arg1 = reinterpret_cast< wxWindow * >(argp1);
35660 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35661 int val;
35662 int ecode = SWIG_AsVal_int(obj1, &val);
35663 if (!SWIG_IsOK(ecode)) {
35664 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35665 }
35666 temp2 = static_cast< int >(val);
35667 arg2 = &temp2;
35668 res2 = SWIG_AddTmpMask(ecode);
35669 }
35670 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35671 int val;
35672 int ecode = SWIG_AsVal_int(obj2, &val);
35673 if (!SWIG_IsOK(ecode)) {
35674 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35675 }
35676 temp3 = static_cast< int >(val);
35677 arg3 = &temp3;
35678 res3 = SWIG_AddTmpMask(ecode);
35679 }
35680 {
35681 PyThreadState* __tstate = wxPyBeginAllowThreads();
35682 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35683 wxPyEndAllowThreads(__tstate);
35684 if (PyErr_Occurred()) SWIG_fail;
35685 }
35686 resultobj = SWIG_Py_Void();
35687 if (SWIG_IsTmpObj(res2)) {
35688 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35689 } else {
35690 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35691 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35692 }
35693 if (SWIG_IsTmpObj(res3)) {
35694 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35695 } else {
35696 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35698 }
35699 return resultobj;
35700 fail:
35701 return NULL;
35702 }
35703
35704
35705 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35706 PyObject *resultobj = 0;
35707 wxWindow *arg1 = (wxWindow *) 0 ;
35708 int *arg2 = (int *) 0 ;
35709 int *arg3 = (int *) 0 ;
35710 void *argp1 = 0 ;
35711 int res1 = 0 ;
35712 int temp2 ;
35713 int res2 = 0 ;
35714 int temp3 ;
35715 int res3 = 0 ;
35716 PyObject * obj0 = 0 ;
35717 PyObject * obj1 = 0 ;
35718 PyObject * obj2 = 0 ;
35719 char * kwnames[] = {
35720 (char *) "self",(char *) "x",(char *) "y", NULL
35721 };
35722
35723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35725 if (!SWIG_IsOK(res1)) {
35726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35727 }
35728 arg1 = reinterpret_cast< wxWindow * >(argp1);
35729 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35730 int val;
35731 int ecode = SWIG_AsVal_int(obj1, &val);
35732 if (!SWIG_IsOK(ecode)) {
35733 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35734 }
35735 temp2 = static_cast< int >(val);
35736 arg2 = &temp2;
35737 res2 = SWIG_AddTmpMask(ecode);
35738 }
35739 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35740 int val;
35741 int ecode = SWIG_AsVal_int(obj2, &val);
35742 if (!SWIG_IsOK(ecode)) {
35743 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35744 }
35745 temp3 = static_cast< int >(val);
35746 arg3 = &temp3;
35747 res3 = SWIG_AddTmpMask(ecode);
35748 }
35749 {
35750 PyThreadState* __tstate = wxPyBeginAllowThreads();
35751 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35752 wxPyEndAllowThreads(__tstate);
35753 if (PyErr_Occurred()) SWIG_fail;
35754 }
35755 resultobj = SWIG_Py_Void();
35756 if (SWIG_IsTmpObj(res2)) {
35757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35758 } else {
35759 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35760 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35761 }
35762 if (SWIG_IsTmpObj(res3)) {
35763 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35764 } else {
35765 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35766 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35767 }
35768 return resultobj;
35769 fail:
35770 return NULL;
35771 }
35772
35773
35774 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35775 PyObject *resultobj = 0;
35776 wxWindow *arg1 = (wxWindow *) 0 ;
35777 wxPoint *arg2 = 0 ;
35778 wxPoint result;
35779 void *argp1 = 0 ;
35780 int res1 = 0 ;
35781 wxPoint temp2 ;
35782 PyObject * obj0 = 0 ;
35783 PyObject * obj1 = 0 ;
35784 char * kwnames[] = {
35785 (char *) "self",(char *) "pt", NULL
35786 };
35787
35788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35790 if (!SWIG_IsOK(res1)) {
35791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35792 }
35793 arg1 = reinterpret_cast< wxWindow * >(argp1);
35794 {
35795 arg2 = &temp2;
35796 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35797 }
35798 {
35799 PyThreadState* __tstate = wxPyBeginAllowThreads();
35800 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35801 wxPyEndAllowThreads(__tstate);
35802 if (PyErr_Occurred()) SWIG_fail;
35803 }
35804 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35805 return resultobj;
35806 fail:
35807 return NULL;
35808 }
35809
35810
35811 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35812 PyObject *resultobj = 0;
35813 wxWindow *arg1 = (wxWindow *) 0 ;
35814 wxPoint *arg2 = 0 ;
35815 wxPoint result;
35816 void *argp1 = 0 ;
35817 int res1 = 0 ;
35818 wxPoint temp2 ;
35819 PyObject * obj0 = 0 ;
35820 PyObject * obj1 = 0 ;
35821 char * kwnames[] = {
35822 (char *) "self",(char *) "pt", NULL
35823 };
35824
35825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35827 if (!SWIG_IsOK(res1)) {
35828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35829 }
35830 arg1 = reinterpret_cast< wxWindow * >(argp1);
35831 {
35832 arg2 = &temp2;
35833 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35834 }
35835 {
35836 PyThreadState* __tstate = wxPyBeginAllowThreads();
35837 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35838 wxPyEndAllowThreads(__tstate);
35839 if (PyErr_Occurred()) SWIG_fail;
35840 }
35841 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35842 return resultobj;
35843 fail:
35844 return NULL;
35845 }
35846
35847
35848 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35849 PyObject *resultobj = 0;
35850 wxWindow *arg1 = (wxWindow *) 0 ;
35851 int arg2 ;
35852 int arg3 ;
35853 wxHitTest result;
35854 void *argp1 = 0 ;
35855 int res1 = 0 ;
35856 int val2 ;
35857 int ecode2 = 0 ;
35858 int val3 ;
35859 int ecode3 = 0 ;
35860 PyObject * obj0 = 0 ;
35861 PyObject * obj1 = 0 ;
35862 PyObject * obj2 = 0 ;
35863 char * kwnames[] = {
35864 (char *) "self",(char *) "x",(char *) "y", NULL
35865 };
35866
35867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35869 if (!SWIG_IsOK(res1)) {
35870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35871 }
35872 arg1 = reinterpret_cast< wxWindow * >(argp1);
35873 ecode2 = SWIG_AsVal_int(obj1, &val2);
35874 if (!SWIG_IsOK(ecode2)) {
35875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35876 }
35877 arg2 = static_cast< int >(val2);
35878 ecode3 = SWIG_AsVal_int(obj2, &val3);
35879 if (!SWIG_IsOK(ecode3)) {
35880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35881 }
35882 arg3 = static_cast< int >(val3);
35883 {
35884 PyThreadState* __tstate = wxPyBeginAllowThreads();
35885 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35886 wxPyEndAllowThreads(__tstate);
35887 if (PyErr_Occurred()) SWIG_fail;
35888 }
35889 resultobj = SWIG_From_int(static_cast< int >(result));
35890 return resultobj;
35891 fail:
35892 return NULL;
35893 }
35894
35895
35896 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35897 PyObject *resultobj = 0;
35898 wxWindow *arg1 = (wxWindow *) 0 ;
35899 wxPoint *arg2 = 0 ;
35900 wxHitTest result;
35901 void *argp1 = 0 ;
35902 int res1 = 0 ;
35903 wxPoint temp2 ;
35904 PyObject * obj0 = 0 ;
35905 PyObject * obj1 = 0 ;
35906 char * kwnames[] = {
35907 (char *) "self",(char *) "pt", NULL
35908 };
35909
35910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35912 if (!SWIG_IsOK(res1)) {
35913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35914 }
35915 arg1 = reinterpret_cast< wxWindow * >(argp1);
35916 {
35917 arg2 = &temp2;
35918 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35919 }
35920 {
35921 PyThreadState* __tstate = wxPyBeginAllowThreads();
35922 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35923 wxPyEndAllowThreads(__tstate);
35924 if (PyErr_Occurred()) SWIG_fail;
35925 }
35926 resultobj = SWIG_From_int(static_cast< int >(result));
35927 return resultobj;
35928 fail:
35929 return NULL;
35930 }
35931
35932
35933 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35934 PyObject *resultobj = 0;
35935 wxWindow *arg1 = (wxWindow *) 0 ;
35936 long arg2 ;
35937 wxBorder result;
35938 void *argp1 = 0 ;
35939 int res1 = 0 ;
35940 long val2 ;
35941 int ecode2 = 0 ;
35942
35943 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35945 if (!SWIG_IsOK(res1)) {
35946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35947 }
35948 arg1 = reinterpret_cast< wxWindow * >(argp1);
35949 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35950 if (!SWIG_IsOK(ecode2)) {
35951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35952 }
35953 arg2 = static_cast< long >(val2);
35954 {
35955 PyThreadState* __tstate = wxPyBeginAllowThreads();
35956 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35957 wxPyEndAllowThreads(__tstate);
35958 if (PyErr_Occurred()) SWIG_fail;
35959 }
35960 resultobj = SWIG_From_int(static_cast< int >(result));
35961 return resultobj;
35962 fail:
35963 return NULL;
35964 }
35965
35966
35967 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35968 PyObject *resultobj = 0;
35969 wxWindow *arg1 = (wxWindow *) 0 ;
35970 wxBorder result;
35971 void *argp1 = 0 ;
35972 int res1 = 0 ;
35973
35974 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35976 if (!SWIG_IsOK(res1)) {
35977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35978 }
35979 arg1 = reinterpret_cast< wxWindow * >(argp1);
35980 {
35981 PyThreadState* __tstate = wxPyBeginAllowThreads();
35982 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35983 wxPyEndAllowThreads(__tstate);
35984 if (PyErr_Occurred()) SWIG_fail;
35985 }
35986 resultobj = SWIG_From_int(static_cast< int >(result));
35987 return resultobj;
35988 fail:
35989 return NULL;
35990 }
35991
35992
35993 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35994 int argc;
35995 PyObject *argv[3];
35996
35997 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35998 --argc;
35999 if (argc == 1) {
36000 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36001 }
36002 if (argc == 2) {
36003 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36004 }
36005
36006 fail:
36007 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36008 return NULL;
36009 }
36010
36011
36012 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36013 PyObject *resultobj = 0;
36014 wxWindow *arg1 = (wxWindow *) 0 ;
36015 long arg2 = (long) wxUPDATE_UI_NONE ;
36016 void *argp1 = 0 ;
36017 int res1 = 0 ;
36018 long val2 ;
36019 int ecode2 = 0 ;
36020 PyObject * obj0 = 0 ;
36021 PyObject * obj1 = 0 ;
36022 char * kwnames[] = {
36023 (char *) "self",(char *) "flags", NULL
36024 };
36025
36026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36028 if (!SWIG_IsOK(res1)) {
36029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36030 }
36031 arg1 = reinterpret_cast< wxWindow * >(argp1);
36032 if (obj1) {
36033 ecode2 = SWIG_AsVal_long(obj1, &val2);
36034 if (!SWIG_IsOK(ecode2)) {
36035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36036 }
36037 arg2 = static_cast< long >(val2);
36038 }
36039 {
36040 PyThreadState* __tstate = wxPyBeginAllowThreads();
36041 (arg1)->UpdateWindowUI(arg2);
36042 wxPyEndAllowThreads(__tstate);
36043 if (PyErr_Occurred()) SWIG_fail;
36044 }
36045 resultobj = SWIG_Py_Void();
36046 return resultobj;
36047 fail:
36048 return NULL;
36049 }
36050
36051
36052 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36053 PyObject *resultobj = 0;
36054 wxWindow *arg1 = (wxWindow *) 0 ;
36055 wxMenu *arg2 = (wxMenu *) 0 ;
36056 int arg3 = (int) -1 ;
36057 int arg4 = (int) -1 ;
36058 bool result;
36059 void *argp1 = 0 ;
36060 int res1 = 0 ;
36061 void *argp2 = 0 ;
36062 int res2 = 0 ;
36063 int val3 ;
36064 int ecode3 = 0 ;
36065 int val4 ;
36066 int ecode4 = 0 ;
36067 PyObject * obj0 = 0 ;
36068 PyObject * obj1 = 0 ;
36069 PyObject * obj2 = 0 ;
36070 PyObject * obj3 = 0 ;
36071 char * kwnames[] = {
36072 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36073 };
36074
36075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36077 if (!SWIG_IsOK(res1)) {
36078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36079 }
36080 arg1 = reinterpret_cast< wxWindow * >(argp1);
36081 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36082 if (!SWIG_IsOK(res2)) {
36083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36084 }
36085 arg2 = reinterpret_cast< wxMenu * >(argp2);
36086 if (obj2) {
36087 ecode3 = SWIG_AsVal_int(obj2, &val3);
36088 if (!SWIG_IsOK(ecode3)) {
36089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36090 }
36091 arg3 = static_cast< int >(val3);
36092 }
36093 if (obj3) {
36094 ecode4 = SWIG_AsVal_int(obj3, &val4);
36095 if (!SWIG_IsOK(ecode4)) {
36096 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36097 }
36098 arg4 = static_cast< int >(val4);
36099 }
36100 {
36101 PyThreadState* __tstate = wxPyBeginAllowThreads();
36102 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36103 wxPyEndAllowThreads(__tstate);
36104 if (PyErr_Occurred()) SWIG_fail;
36105 }
36106 {
36107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36108 }
36109 return resultobj;
36110 fail:
36111 return NULL;
36112 }
36113
36114
36115 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36116 PyObject *resultobj = 0;
36117 wxWindow *arg1 = (wxWindow *) 0 ;
36118 wxMenu *arg2 = (wxMenu *) 0 ;
36119 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36120 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36121 bool result;
36122 void *argp1 = 0 ;
36123 int res1 = 0 ;
36124 void *argp2 = 0 ;
36125 int res2 = 0 ;
36126 wxPoint temp3 ;
36127 PyObject * obj0 = 0 ;
36128 PyObject * obj1 = 0 ;
36129 PyObject * obj2 = 0 ;
36130 char * kwnames[] = {
36131 (char *) "self",(char *) "menu",(char *) "pos", NULL
36132 };
36133
36134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36136 if (!SWIG_IsOK(res1)) {
36137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36138 }
36139 arg1 = reinterpret_cast< wxWindow * >(argp1);
36140 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36141 if (!SWIG_IsOK(res2)) {
36142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36143 }
36144 arg2 = reinterpret_cast< wxMenu * >(argp2);
36145 if (obj2) {
36146 {
36147 arg3 = &temp3;
36148 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36149 }
36150 }
36151 {
36152 PyThreadState* __tstate = wxPyBeginAllowThreads();
36153 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36154 wxPyEndAllowThreads(__tstate);
36155 if (PyErr_Occurred()) SWIG_fail;
36156 }
36157 {
36158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36159 }
36160 return resultobj;
36161 fail:
36162 return NULL;
36163 }
36164
36165
36166 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36167 PyObject *resultobj = 0;
36168 wxWindow *arg1 = (wxWindow *) 0 ;
36169 bool result;
36170 void *argp1 = 0 ;
36171 int res1 = 0 ;
36172 PyObject *swig_obj[1] ;
36173
36174 if (!args) SWIG_fail;
36175 swig_obj[0] = args;
36176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36177 if (!SWIG_IsOK(res1)) {
36178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36179 }
36180 arg1 = reinterpret_cast< wxWindow * >(argp1);
36181 {
36182 PyThreadState* __tstate = wxPyBeginAllowThreads();
36183 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36184 wxPyEndAllowThreads(__tstate);
36185 if (PyErr_Occurred()) SWIG_fail;
36186 }
36187 {
36188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36189 }
36190 return resultobj;
36191 fail:
36192 return NULL;
36193 }
36194
36195
36196 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36197 PyObject *resultobj = 0;
36198 wxWindow *arg1 = (wxWindow *) 0 ;
36199 long result;
36200 void *argp1 = 0 ;
36201 int res1 = 0 ;
36202 PyObject *swig_obj[1] ;
36203
36204 if (!args) SWIG_fail;
36205 swig_obj[0] = args;
36206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36207 if (!SWIG_IsOK(res1)) {
36208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36209 }
36210 arg1 = reinterpret_cast< wxWindow * >(argp1);
36211 {
36212 PyThreadState* __tstate = wxPyBeginAllowThreads();
36213 result = (long)wxWindow_GetHandle(arg1);
36214 wxPyEndAllowThreads(__tstate);
36215 if (PyErr_Occurred()) SWIG_fail;
36216 }
36217 resultobj = SWIG_From_long(static_cast< long >(result));
36218 return resultobj;
36219 fail:
36220 return NULL;
36221 }
36222
36223
36224 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36225 PyObject *resultobj = 0;
36226 wxWindow *arg1 = (wxWindow *) 0 ;
36227 long arg2 ;
36228 void *argp1 = 0 ;
36229 int res1 = 0 ;
36230 long val2 ;
36231 int ecode2 = 0 ;
36232 PyObject * obj0 = 0 ;
36233 PyObject * obj1 = 0 ;
36234 char * kwnames[] = {
36235 (char *) "self",(char *) "handle", NULL
36236 };
36237
36238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36240 if (!SWIG_IsOK(res1)) {
36241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36242 }
36243 arg1 = reinterpret_cast< wxWindow * >(argp1);
36244 ecode2 = SWIG_AsVal_long(obj1, &val2);
36245 if (!SWIG_IsOK(ecode2)) {
36246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36247 }
36248 arg2 = static_cast< long >(val2);
36249 {
36250 PyThreadState* __tstate = wxPyBeginAllowThreads();
36251 wxWindow_AssociateHandle(arg1,arg2);
36252 wxPyEndAllowThreads(__tstate);
36253 if (PyErr_Occurred()) SWIG_fail;
36254 }
36255 resultobj = SWIG_Py_Void();
36256 return resultobj;
36257 fail:
36258 return NULL;
36259 }
36260
36261
36262 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36263 PyObject *resultobj = 0;
36264 wxWindow *arg1 = (wxWindow *) 0 ;
36265 void *argp1 = 0 ;
36266 int res1 = 0 ;
36267 PyObject *swig_obj[1] ;
36268
36269 if (!args) SWIG_fail;
36270 swig_obj[0] = args;
36271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36272 if (!SWIG_IsOK(res1)) {
36273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36274 }
36275 arg1 = reinterpret_cast< wxWindow * >(argp1);
36276 {
36277 PyThreadState* __tstate = wxPyBeginAllowThreads();
36278 (arg1)->DissociateHandle();
36279 wxPyEndAllowThreads(__tstate);
36280 if (PyErr_Occurred()) SWIG_fail;
36281 }
36282 resultobj = SWIG_Py_Void();
36283 return resultobj;
36284 fail:
36285 return NULL;
36286 }
36287
36288
36289 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36290 PyObject *resultobj = 0;
36291 wxWindow *arg1 = (wxWindow *) 0 ;
36292 int arg2 ;
36293 bool result;
36294 void *argp1 = 0 ;
36295 int res1 = 0 ;
36296 int val2 ;
36297 int ecode2 = 0 ;
36298 PyObject * obj0 = 0 ;
36299 PyObject * obj1 = 0 ;
36300 char * kwnames[] = {
36301 (char *) "self",(char *) "orient", NULL
36302 };
36303
36304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36306 if (!SWIG_IsOK(res1)) {
36307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36308 }
36309 arg1 = reinterpret_cast< wxWindow * >(argp1);
36310 ecode2 = SWIG_AsVal_int(obj1, &val2);
36311 if (!SWIG_IsOK(ecode2)) {
36312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36313 }
36314 arg2 = static_cast< int >(val2);
36315 {
36316 PyThreadState* __tstate = wxPyBeginAllowThreads();
36317 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36318 wxPyEndAllowThreads(__tstate);
36319 if (PyErr_Occurred()) SWIG_fail;
36320 }
36321 {
36322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36323 }
36324 return resultobj;
36325 fail:
36326 return NULL;
36327 }
36328
36329
36330 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36331 PyObject *resultobj = 0;
36332 wxWindow *arg1 = (wxWindow *) 0 ;
36333 int arg2 ;
36334 int arg3 ;
36335 int arg4 ;
36336 int arg5 ;
36337 bool arg6 = (bool) true ;
36338 void *argp1 = 0 ;
36339 int res1 = 0 ;
36340 int val2 ;
36341 int ecode2 = 0 ;
36342 int val3 ;
36343 int ecode3 = 0 ;
36344 int val4 ;
36345 int ecode4 = 0 ;
36346 int val5 ;
36347 int ecode5 = 0 ;
36348 bool val6 ;
36349 int ecode6 = 0 ;
36350 PyObject * obj0 = 0 ;
36351 PyObject * obj1 = 0 ;
36352 PyObject * obj2 = 0 ;
36353 PyObject * obj3 = 0 ;
36354 PyObject * obj4 = 0 ;
36355 PyObject * obj5 = 0 ;
36356 char * kwnames[] = {
36357 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36358 };
36359
36360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36362 if (!SWIG_IsOK(res1)) {
36363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36364 }
36365 arg1 = reinterpret_cast< wxWindow * >(argp1);
36366 ecode2 = SWIG_AsVal_int(obj1, &val2);
36367 if (!SWIG_IsOK(ecode2)) {
36368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36369 }
36370 arg2 = static_cast< int >(val2);
36371 ecode3 = SWIG_AsVal_int(obj2, &val3);
36372 if (!SWIG_IsOK(ecode3)) {
36373 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36374 }
36375 arg3 = static_cast< int >(val3);
36376 ecode4 = SWIG_AsVal_int(obj3, &val4);
36377 if (!SWIG_IsOK(ecode4)) {
36378 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36379 }
36380 arg4 = static_cast< int >(val4);
36381 ecode5 = SWIG_AsVal_int(obj4, &val5);
36382 if (!SWIG_IsOK(ecode5)) {
36383 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36384 }
36385 arg5 = static_cast< int >(val5);
36386 if (obj5) {
36387 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36388 if (!SWIG_IsOK(ecode6)) {
36389 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36390 }
36391 arg6 = static_cast< bool >(val6);
36392 }
36393 {
36394 PyThreadState* __tstate = wxPyBeginAllowThreads();
36395 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36396 wxPyEndAllowThreads(__tstate);
36397 if (PyErr_Occurred()) SWIG_fail;
36398 }
36399 resultobj = SWIG_Py_Void();
36400 return resultobj;
36401 fail:
36402 return NULL;
36403 }
36404
36405
36406 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36407 PyObject *resultobj = 0;
36408 wxWindow *arg1 = (wxWindow *) 0 ;
36409 int arg2 ;
36410 int arg3 ;
36411 bool arg4 = (bool) true ;
36412 void *argp1 = 0 ;
36413 int res1 = 0 ;
36414 int val2 ;
36415 int ecode2 = 0 ;
36416 int val3 ;
36417 int ecode3 = 0 ;
36418 bool val4 ;
36419 int ecode4 = 0 ;
36420 PyObject * obj0 = 0 ;
36421 PyObject * obj1 = 0 ;
36422 PyObject * obj2 = 0 ;
36423 PyObject * obj3 = 0 ;
36424 char * kwnames[] = {
36425 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36426 };
36427
36428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36430 if (!SWIG_IsOK(res1)) {
36431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36432 }
36433 arg1 = reinterpret_cast< wxWindow * >(argp1);
36434 ecode2 = SWIG_AsVal_int(obj1, &val2);
36435 if (!SWIG_IsOK(ecode2)) {
36436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36437 }
36438 arg2 = static_cast< int >(val2);
36439 ecode3 = SWIG_AsVal_int(obj2, &val3);
36440 if (!SWIG_IsOK(ecode3)) {
36441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36442 }
36443 arg3 = static_cast< int >(val3);
36444 if (obj3) {
36445 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36446 if (!SWIG_IsOK(ecode4)) {
36447 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36448 }
36449 arg4 = static_cast< bool >(val4);
36450 }
36451 {
36452 PyThreadState* __tstate = wxPyBeginAllowThreads();
36453 (arg1)->SetScrollPos(arg2,arg3,arg4);
36454 wxPyEndAllowThreads(__tstate);
36455 if (PyErr_Occurred()) SWIG_fail;
36456 }
36457 resultobj = SWIG_Py_Void();
36458 return resultobj;
36459 fail:
36460 return NULL;
36461 }
36462
36463
36464 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36465 PyObject *resultobj = 0;
36466 wxWindow *arg1 = (wxWindow *) 0 ;
36467 int arg2 ;
36468 int result;
36469 void *argp1 = 0 ;
36470 int res1 = 0 ;
36471 int val2 ;
36472 int ecode2 = 0 ;
36473 PyObject * obj0 = 0 ;
36474 PyObject * obj1 = 0 ;
36475 char * kwnames[] = {
36476 (char *) "self",(char *) "orientation", NULL
36477 };
36478
36479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36481 if (!SWIG_IsOK(res1)) {
36482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36483 }
36484 arg1 = reinterpret_cast< wxWindow * >(argp1);
36485 ecode2 = SWIG_AsVal_int(obj1, &val2);
36486 if (!SWIG_IsOK(ecode2)) {
36487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36488 }
36489 arg2 = static_cast< int >(val2);
36490 {
36491 PyThreadState* __tstate = wxPyBeginAllowThreads();
36492 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36493 wxPyEndAllowThreads(__tstate);
36494 if (PyErr_Occurred()) SWIG_fail;
36495 }
36496 resultobj = SWIG_From_int(static_cast< int >(result));
36497 return resultobj;
36498 fail:
36499 return NULL;
36500 }
36501
36502
36503 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36504 PyObject *resultobj = 0;
36505 wxWindow *arg1 = (wxWindow *) 0 ;
36506 int arg2 ;
36507 int result;
36508 void *argp1 = 0 ;
36509 int res1 = 0 ;
36510 int val2 ;
36511 int ecode2 = 0 ;
36512 PyObject * obj0 = 0 ;
36513 PyObject * obj1 = 0 ;
36514 char * kwnames[] = {
36515 (char *) "self",(char *) "orientation", NULL
36516 };
36517
36518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36520 if (!SWIG_IsOK(res1)) {
36521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36522 }
36523 arg1 = reinterpret_cast< wxWindow * >(argp1);
36524 ecode2 = SWIG_AsVal_int(obj1, &val2);
36525 if (!SWIG_IsOK(ecode2)) {
36526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36527 }
36528 arg2 = static_cast< int >(val2);
36529 {
36530 PyThreadState* __tstate = wxPyBeginAllowThreads();
36531 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36532 wxPyEndAllowThreads(__tstate);
36533 if (PyErr_Occurred()) SWIG_fail;
36534 }
36535 resultobj = SWIG_From_int(static_cast< int >(result));
36536 return resultobj;
36537 fail:
36538 return NULL;
36539 }
36540
36541
36542 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36543 PyObject *resultobj = 0;
36544 wxWindow *arg1 = (wxWindow *) 0 ;
36545 int arg2 ;
36546 int result;
36547 void *argp1 = 0 ;
36548 int res1 = 0 ;
36549 int val2 ;
36550 int ecode2 = 0 ;
36551 PyObject * obj0 = 0 ;
36552 PyObject * obj1 = 0 ;
36553 char * kwnames[] = {
36554 (char *) "self",(char *) "orientation", NULL
36555 };
36556
36557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36559 if (!SWIG_IsOK(res1)) {
36560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36561 }
36562 arg1 = reinterpret_cast< wxWindow * >(argp1);
36563 ecode2 = SWIG_AsVal_int(obj1, &val2);
36564 if (!SWIG_IsOK(ecode2)) {
36565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36566 }
36567 arg2 = static_cast< int >(val2);
36568 {
36569 PyThreadState* __tstate = wxPyBeginAllowThreads();
36570 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36571 wxPyEndAllowThreads(__tstate);
36572 if (PyErr_Occurred()) SWIG_fail;
36573 }
36574 resultobj = SWIG_From_int(static_cast< int >(result));
36575 return resultobj;
36576 fail:
36577 return NULL;
36578 }
36579
36580
36581 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36582 PyObject *resultobj = 0;
36583 wxWindow *arg1 = (wxWindow *) 0 ;
36584 int arg2 ;
36585 int arg3 ;
36586 wxRect *arg4 = (wxRect *) NULL ;
36587 void *argp1 = 0 ;
36588 int res1 = 0 ;
36589 int val2 ;
36590 int ecode2 = 0 ;
36591 int val3 ;
36592 int ecode3 = 0 ;
36593 void *argp4 = 0 ;
36594 int res4 = 0 ;
36595 PyObject * obj0 = 0 ;
36596 PyObject * obj1 = 0 ;
36597 PyObject * obj2 = 0 ;
36598 PyObject * obj3 = 0 ;
36599 char * kwnames[] = {
36600 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36601 };
36602
36603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36605 if (!SWIG_IsOK(res1)) {
36606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36607 }
36608 arg1 = reinterpret_cast< wxWindow * >(argp1);
36609 ecode2 = SWIG_AsVal_int(obj1, &val2);
36610 if (!SWIG_IsOK(ecode2)) {
36611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36612 }
36613 arg2 = static_cast< int >(val2);
36614 ecode3 = SWIG_AsVal_int(obj2, &val3);
36615 if (!SWIG_IsOK(ecode3)) {
36616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36617 }
36618 arg3 = static_cast< int >(val3);
36619 if (obj3) {
36620 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36621 if (!SWIG_IsOK(res4)) {
36622 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36623 }
36624 arg4 = reinterpret_cast< wxRect * >(argp4);
36625 }
36626 {
36627 PyThreadState* __tstate = wxPyBeginAllowThreads();
36628 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36629 wxPyEndAllowThreads(__tstate);
36630 if (PyErr_Occurred()) SWIG_fail;
36631 }
36632 resultobj = SWIG_Py_Void();
36633 return resultobj;
36634 fail:
36635 return NULL;
36636 }
36637
36638
36639 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36640 PyObject *resultobj = 0;
36641 wxWindow *arg1 = (wxWindow *) 0 ;
36642 int arg2 ;
36643 bool result;
36644 void *argp1 = 0 ;
36645 int res1 = 0 ;
36646 int val2 ;
36647 int ecode2 = 0 ;
36648 PyObject * obj0 = 0 ;
36649 PyObject * obj1 = 0 ;
36650 char * kwnames[] = {
36651 (char *) "self",(char *) "lines", NULL
36652 };
36653
36654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36656 if (!SWIG_IsOK(res1)) {
36657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36658 }
36659 arg1 = reinterpret_cast< wxWindow * >(argp1);
36660 ecode2 = SWIG_AsVal_int(obj1, &val2);
36661 if (!SWIG_IsOK(ecode2)) {
36662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36663 }
36664 arg2 = static_cast< int >(val2);
36665 {
36666 PyThreadState* __tstate = wxPyBeginAllowThreads();
36667 result = (bool)(arg1)->ScrollLines(arg2);
36668 wxPyEndAllowThreads(__tstate);
36669 if (PyErr_Occurred()) SWIG_fail;
36670 }
36671 {
36672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36673 }
36674 return resultobj;
36675 fail:
36676 return NULL;
36677 }
36678
36679
36680 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36681 PyObject *resultobj = 0;
36682 wxWindow *arg1 = (wxWindow *) 0 ;
36683 int arg2 ;
36684 bool result;
36685 void *argp1 = 0 ;
36686 int res1 = 0 ;
36687 int val2 ;
36688 int ecode2 = 0 ;
36689 PyObject * obj0 = 0 ;
36690 PyObject * obj1 = 0 ;
36691 char * kwnames[] = {
36692 (char *) "self",(char *) "pages", NULL
36693 };
36694
36695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36697 if (!SWIG_IsOK(res1)) {
36698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36699 }
36700 arg1 = reinterpret_cast< wxWindow * >(argp1);
36701 ecode2 = SWIG_AsVal_int(obj1, &val2);
36702 if (!SWIG_IsOK(ecode2)) {
36703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36704 }
36705 arg2 = static_cast< int >(val2);
36706 {
36707 PyThreadState* __tstate = wxPyBeginAllowThreads();
36708 result = (bool)(arg1)->ScrollPages(arg2);
36709 wxPyEndAllowThreads(__tstate);
36710 if (PyErr_Occurred()) SWIG_fail;
36711 }
36712 {
36713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36714 }
36715 return resultobj;
36716 fail:
36717 return NULL;
36718 }
36719
36720
36721 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36722 PyObject *resultobj = 0;
36723 wxWindow *arg1 = (wxWindow *) 0 ;
36724 bool result;
36725 void *argp1 = 0 ;
36726 int res1 = 0 ;
36727 PyObject *swig_obj[1] ;
36728
36729 if (!args) SWIG_fail;
36730 swig_obj[0] = args;
36731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36732 if (!SWIG_IsOK(res1)) {
36733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36734 }
36735 arg1 = reinterpret_cast< wxWindow * >(argp1);
36736 {
36737 PyThreadState* __tstate = wxPyBeginAllowThreads();
36738 result = (bool)(arg1)->LineUp();
36739 wxPyEndAllowThreads(__tstate);
36740 if (PyErr_Occurred()) SWIG_fail;
36741 }
36742 {
36743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36744 }
36745 return resultobj;
36746 fail:
36747 return NULL;
36748 }
36749
36750
36751 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36752 PyObject *resultobj = 0;
36753 wxWindow *arg1 = (wxWindow *) 0 ;
36754 bool result;
36755 void *argp1 = 0 ;
36756 int res1 = 0 ;
36757 PyObject *swig_obj[1] ;
36758
36759 if (!args) SWIG_fail;
36760 swig_obj[0] = args;
36761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36762 if (!SWIG_IsOK(res1)) {
36763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36764 }
36765 arg1 = reinterpret_cast< wxWindow * >(argp1);
36766 {
36767 PyThreadState* __tstate = wxPyBeginAllowThreads();
36768 result = (bool)(arg1)->LineDown();
36769 wxPyEndAllowThreads(__tstate);
36770 if (PyErr_Occurred()) SWIG_fail;
36771 }
36772 {
36773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36774 }
36775 return resultobj;
36776 fail:
36777 return NULL;
36778 }
36779
36780
36781 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36782 PyObject *resultobj = 0;
36783 wxWindow *arg1 = (wxWindow *) 0 ;
36784 bool result;
36785 void *argp1 = 0 ;
36786 int res1 = 0 ;
36787 PyObject *swig_obj[1] ;
36788
36789 if (!args) SWIG_fail;
36790 swig_obj[0] = args;
36791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36792 if (!SWIG_IsOK(res1)) {
36793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36794 }
36795 arg1 = reinterpret_cast< wxWindow * >(argp1);
36796 {
36797 PyThreadState* __tstate = wxPyBeginAllowThreads();
36798 result = (bool)(arg1)->PageUp();
36799 wxPyEndAllowThreads(__tstate);
36800 if (PyErr_Occurred()) SWIG_fail;
36801 }
36802 {
36803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36804 }
36805 return resultobj;
36806 fail:
36807 return NULL;
36808 }
36809
36810
36811 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36812 PyObject *resultobj = 0;
36813 wxWindow *arg1 = (wxWindow *) 0 ;
36814 bool result;
36815 void *argp1 = 0 ;
36816 int res1 = 0 ;
36817 PyObject *swig_obj[1] ;
36818
36819 if (!args) SWIG_fail;
36820 swig_obj[0] = args;
36821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36822 if (!SWIG_IsOK(res1)) {
36823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36824 }
36825 arg1 = reinterpret_cast< wxWindow * >(argp1);
36826 {
36827 PyThreadState* __tstate = wxPyBeginAllowThreads();
36828 result = (bool)(arg1)->PageDown();
36829 wxPyEndAllowThreads(__tstate);
36830 if (PyErr_Occurred()) SWIG_fail;
36831 }
36832 {
36833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36834 }
36835 return resultobj;
36836 fail:
36837 return NULL;
36838 }
36839
36840
36841 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36842 PyObject *resultobj = 0;
36843 wxWindow *arg1 = (wxWindow *) 0 ;
36844 wxString *arg2 = 0 ;
36845 void *argp1 = 0 ;
36846 int res1 = 0 ;
36847 bool temp2 = false ;
36848 PyObject * obj0 = 0 ;
36849 PyObject * obj1 = 0 ;
36850 char * kwnames[] = {
36851 (char *) "self",(char *) "text", NULL
36852 };
36853
36854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36856 if (!SWIG_IsOK(res1)) {
36857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36858 }
36859 arg1 = reinterpret_cast< wxWindow * >(argp1);
36860 {
36861 arg2 = wxString_in_helper(obj1);
36862 if (arg2 == NULL) SWIG_fail;
36863 temp2 = true;
36864 }
36865 {
36866 PyThreadState* __tstate = wxPyBeginAllowThreads();
36867 (arg1)->SetHelpText((wxString const &)*arg2);
36868 wxPyEndAllowThreads(__tstate);
36869 if (PyErr_Occurred()) SWIG_fail;
36870 }
36871 resultobj = SWIG_Py_Void();
36872 {
36873 if (temp2)
36874 delete arg2;
36875 }
36876 return resultobj;
36877 fail:
36878 {
36879 if (temp2)
36880 delete arg2;
36881 }
36882 return NULL;
36883 }
36884
36885
36886 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36887 PyObject *resultobj = 0;
36888 wxWindow *arg1 = (wxWindow *) 0 ;
36889 wxString *arg2 = 0 ;
36890 void *argp1 = 0 ;
36891 int res1 = 0 ;
36892 bool temp2 = false ;
36893 PyObject * obj0 = 0 ;
36894 PyObject * obj1 = 0 ;
36895 char * kwnames[] = {
36896 (char *) "self",(char *) "text", NULL
36897 };
36898
36899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36901 if (!SWIG_IsOK(res1)) {
36902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36903 }
36904 arg1 = reinterpret_cast< wxWindow * >(argp1);
36905 {
36906 arg2 = wxString_in_helper(obj1);
36907 if (arg2 == NULL) SWIG_fail;
36908 temp2 = true;
36909 }
36910 {
36911 PyThreadState* __tstate = wxPyBeginAllowThreads();
36912 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36913 wxPyEndAllowThreads(__tstate);
36914 if (PyErr_Occurred()) SWIG_fail;
36915 }
36916 resultobj = SWIG_Py_Void();
36917 {
36918 if (temp2)
36919 delete arg2;
36920 }
36921 return resultobj;
36922 fail:
36923 {
36924 if (temp2)
36925 delete arg2;
36926 }
36927 return NULL;
36928 }
36929
36930
36931 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36932 PyObject *resultobj = 0;
36933 wxWindow *arg1 = (wxWindow *) 0 ;
36934 wxPoint *arg2 = 0 ;
36935 wxHelpEvent::Origin arg3 ;
36936 wxString result;
36937 void *argp1 = 0 ;
36938 int res1 = 0 ;
36939 wxPoint temp2 ;
36940 void *argp3 ;
36941 int res3 = 0 ;
36942 PyObject * obj0 = 0 ;
36943 PyObject * obj1 = 0 ;
36944 PyObject * obj2 = 0 ;
36945 char * kwnames[] = {
36946 (char *) "self",(char *) "pt",(char *) "origin", NULL
36947 };
36948
36949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36951 if (!SWIG_IsOK(res1)) {
36952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
36953 }
36954 arg1 = reinterpret_cast< wxWindow * >(argp1);
36955 {
36956 arg2 = &temp2;
36957 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36958 }
36959 {
36960 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
36961 if (!SWIG_IsOK(res3)) {
36962 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36963 }
36964 if (!argp3) {
36965 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36966 } else {
36967 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
36968 arg3 = *temp;
36969 if (SWIG_IsNewObj(res3)) delete temp;
36970 }
36971 }
36972 {
36973 PyThreadState* __tstate = wxPyBeginAllowThreads();
36974 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
36975 wxPyEndAllowThreads(__tstate);
36976 if (PyErr_Occurred()) SWIG_fail;
36977 }
36978 {
36979 #if wxUSE_UNICODE
36980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36981 #else
36982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36983 #endif
36984 }
36985 return resultobj;
36986 fail:
36987 return NULL;
36988 }
36989
36990
36991 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36992 PyObject *resultobj = 0;
36993 wxWindow *arg1 = (wxWindow *) 0 ;
36994 wxString result;
36995 void *argp1 = 0 ;
36996 int res1 = 0 ;
36997 PyObject *swig_obj[1] ;
36998
36999 if (!args) SWIG_fail;
37000 swig_obj[0] = args;
37001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37002 if (!SWIG_IsOK(res1)) {
37003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37004 }
37005 arg1 = reinterpret_cast< wxWindow * >(argp1);
37006 {
37007 PyThreadState* __tstate = wxPyBeginAllowThreads();
37008 result = ((wxWindow const *)arg1)->GetHelpText();
37009 wxPyEndAllowThreads(__tstate);
37010 if (PyErr_Occurred()) SWIG_fail;
37011 }
37012 {
37013 #if wxUSE_UNICODE
37014 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37015 #else
37016 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37017 #endif
37018 }
37019 return resultobj;
37020 fail:
37021 return NULL;
37022 }
37023
37024
37025 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37026 PyObject *resultobj = 0;
37027 wxWindow *arg1 = (wxWindow *) 0 ;
37028 wxString *arg2 = 0 ;
37029 void *argp1 = 0 ;
37030 int res1 = 0 ;
37031 bool temp2 = false ;
37032 PyObject * obj0 = 0 ;
37033 PyObject * obj1 = 0 ;
37034 char * kwnames[] = {
37035 (char *) "self",(char *) "tip", NULL
37036 };
37037
37038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37040 if (!SWIG_IsOK(res1)) {
37041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37042 }
37043 arg1 = reinterpret_cast< wxWindow * >(argp1);
37044 {
37045 arg2 = wxString_in_helper(obj1);
37046 if (arg2 == NULL) SWIG_fail;
37047 temp2 = true;
37048 }
37049 {
37050 PyThreadState* __tstate = wxPyBeginAllowThreads();
37051 (arg1)->SetToolTip((wxString const &)*arg2);
37052 wxPyEndAllowThreads(__tstate);
37053 if (PyErr_Occurred()) SWIG_fail;
37054 }
37055 resultobj = SWIG_Py_Void();
37056 {
37057 if (temp2)
37058 delete arg2;
37059 }
37060 return resultobj;
37061 fail:
37062 {
37063 if (temp2)
37064 delete arg2;
37065 }
37066 return NULL;
37067 }
37068
37069
37070 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37071 PyObject *resultobj = 0;
37072 wxWindow *arg1 = (wxWindow *) 0 ;
37073 wxToolTip *arg2 = (wxToolTip *) 0 ;
37074 void *argp1 = 0 ;
37075 int res1 = 0 ;
37076 int res2 = 0 ;
37077 PyObject * obj0 = 0 ;
37078 PyObject * obj1 = 0 ;
37079 char * kwnames[] = {
37080 (char *) "self",(char *) "tip", NULL
37081 };
37082
37083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37085 if (!SWIG_IsOK(res1)) {
37086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37087 }
37088 arg1 = reinterpret_cast< wxWindow * >(argp1);
37089 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37090 if (!SWIG_IsOK(res2)) {
37091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37092 }
37093 {
37094 PyThreadState* __tstate = wxPyBeginAllowThreads();
37095 (arg1)->SetToolTip(arg2);
37096 wxPyEndAllowThreads(__tstate);
37097 if (PyErr_Occurred()) SWIG_fail;
37098 }
37099 resultobj = SWIG_Py_Void();
37100 return resultobj;
37101 fail:
37102 return NULL;
37103 }
37104
37105
37106 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37107 PyObject *resultobj = 0;
37108 wxWindow *arg1 = (wxWindow *) 0 ;
37109 wxToolTip *result = 0 ;
37110 void *argp1 = 0 ;
37111 int res1 = 0 ;
37112 PyObject *swig_obj[1] ;
37113
37114 if (!args) SWIG_fail;
37115 swig_obj[0] = args;
37116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37117 if (!SWIG_IsOK(res1)) {
37118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37119 }
37120 arg1 = reinterpret_cast< wxWindow * >(argp1);
37121 {
37122 PyThreadState* __tstate = wxPyBeginAllowThreads();
37123 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37124 wxPyEndAllowThreads(__tstate);
37125 if (PyErr_Occurred()) SWIG_fail;
37126 }
37127 {
37128 resultobj = wxPyMake_wxObject(result, (bool)0);
37129 }
37130 return resultobj;
37131 fail:
37132 return NULL;
37133 }
37134
37135
37136 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37137 PyObject *resultobj = 0;
37138 wxWindow *arg1 = (wxWindow *) 0 ;
37139 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37140 void *argp1 = 0 ;
37141 int res1 = 0 ;
37142 int res2 = 0 ;
37143 PyObject * obj0 = 0 ;
37144 PyObject * obj1 = 0 ;
37145 char * kwnames[] = {
37146 (char *) "self",(char *) "dropTarget", NULL
37147 };
37148
37149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37151 if (!SWIG_IsOK(res1)) {
37152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37153 }
37154 arg1 = reinterpret_cast< wxWindow * >(argp1);
37155 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37156 if (!SWIG_IsOK(res2)) {
37157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37158 }
37159 {
37160 PyThreadState* __tstate = wxPyBeginAllowThreads();
37161 (arg1)->SetDropTarget(arg2);
37162 wxPyEndAllowThreads(__tstate);
37163 if (PyErr_Occurred()) SWIG_fail;
37164 }
37165 resultobj = SWIG_Py_Void();
37166 return resultobj;
37167 fail:
37168 return NULL;
37169 }
37170
37171
37172 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37173 PyObject *resultobj = 0;
37174 wxWindow *arg1 = (wxWindow *) 0 ;
37175 wxPyDropTarget *result = 0 ;
37176 void *argp1 = 0 ;
37177 int res1 = 0 ;
37178 PyObject *swig_obj[1] ;
37179
37180 if (!args) SWIG_fail;
37181 swig_obj[0] = args;
37182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37183 if (!SWIG_IsOK(res1)) {
37184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37185 }
37186 arg1 = reinterpret_cast< wxWindow * >(argp1);
37187 {
37188 PyThreadState* __tstate = wxPyBeginAllowThreads();
37189 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37190 wxPyEndAllowThreads(__tstate);
37191 if (PyErr_Occurred()) SWIG_fail;
37192 }
37193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37194 return resultobj;
37195 fail:
37196 return NULL;
37197 }
37198
37199
37200 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37201 PyObject *resultobj = 0;
37202 wxWindow *arg1 = (wxWindow *) 0 ;
37203 bool arg2 ;
37204 void *argp1 = 0 ;
37205 int res1 = 0 ;
37206 bool val2 ;
37207 int ecode2 = 0 ;
37208 PyObject * obj0 = 0 ;
37209 PyObject * obj1 = 0 ;
37210 char * kwnames[] = {
37211 (char *) "self",(char *) "accept", NULL
37212 };
37213
37214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37216 if (!SWIG_IsOK(res1)) {
37217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37218 }
37219 arg1 = reinterpret_cast< wxWindow * >(argp1);
37220 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37221 if (!SWIG_IsOK(ecode2)) {
37222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37223 }
37224 arg2 = static_cast< bool >(val2);
37225 {
37226 PyThreadState* __tstate = wxPyBeginAllowThreads();
37227 wxWindow_DragAcceptFiles(arg1,arg2);
37228 wxPyEndAllowThreads(__tstate);
37229 if (PyErr_Occurred()) SWIG_fail;
37230 }
37231 resultobj = SWIG_Py_Void();
37232 return resultobj;
37233 fail:
37234 return NULL;
37235 }
37236
37237
37238 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37239 PyObject *resultobj = 0;
37240 wxWindow *arg1 = (wxWindow *) 0 ;
37241 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37242 void *argp1 = 0 ;
37243 int res1 = 0 ;
37244 int res2 = 0 ;
37245 PyObject * obj0 = 0 ;
37246 PyObject * obj1 = 0 ;
37247 char * kwnames[] = {
37248 (char *) "self",(char *) "constraints", NULL
37249 };
37250
37251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37253 if (!SWIG_IsOK(res1)) {
37254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37255 }
37256 arg1 = reinterpret_cast< wxWindow * >(argp1);
37257 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37258 if (!SWIG_IsOK(res2)) {
37259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37260 }
37261 {
37262 PyThreadState* __tstate = wxPyBeginAllowThreads();
37263 (arg1)->SetConstraints(arg2);
37264 wxPyEndAllowThreads(__tstate);
37265 if (PyErr_Occurred()) SWIG_fail;
37266 }
37267 resultobj = SWIG_Py_Void();
37268 return resultobj;
37269 fail:
37270 return NULL;
37271 }
37272
37273
37274 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37275 PyObject *resultobj = 0;
37276 wxWindow *arg1 = (wxWindow *) 0 ;
37277 wxLayoutConstraints *result = 0 ;
37278 void *argp1 = 0 ;
37279 int res1 = 0 ;
37280 PyObject *swig_obj[1] ;
37281
37282 if (!args) SWIG_fail;
37283 swig_obj[0] = args;
37284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37285 if (!SWIG_IsOK(res1)) {
37286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37287 }
37288 arg1 = reinterpret_cast< wxWindow * >(argp1);
37289 {
37290 PyThreadState* __tstate = wxPyBeginAllowThreads();
37291 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37292 wxPyEndAllowThreads(__tstate);
37293 if (PyErr_Occurred()) SWIG_fail;
37294 }
37295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37296 return resultobj;
37297 fail:
37298 return NULL;
37299 }
37300
37301
37302 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37303 PyObject *resultobj = 0;
37304 wxWindow *arg1 = (wxWindow *) 0 ;
37305 bool arg2 ;
37306 void *argp1 = 0 ;
37307 int res1 = 0 ;
37308 bool val2 ;
37309 int ecode2 = 0 ;
37310 PyObject * obj0 = 0 ;
37311 PyObject * obj1 = 0 ;
37312 char * kwnames[] = {
37313 (char *) "self",(char *) "autoLayout", NULL
37314 };
37315
37316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37318 if (!SWIG_IsOK(res1)) {
37319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37320 }
37321 arg1 = reinterpret_cast< wxWindow * >(argp1);
37322 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37323 if (!SWIG_IsOK(ecode2)) {
37324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37325 }
37326 arg2 = static_cast< bool >(val2);
37327 {
37328 PyThreadState* __tstate = wxPyBeginAllowThreads();
37329 (arg1)->SetAutoLayout(arg2);
37330 wxPyEndAllowThreads(__tstate);
37331 if (PyErr_Occurred()) SWIG_fail;
37332 }
37333 resultobj = SWIG_Py_Void();
37334 return resultobj;
37335 fail:
37336 return NULL;
37337 }
37338
37339
37340 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37341 PyObject *resultobj = 0;
37342 wxWindow *arg1 = (wxWindow *) 0 ;
37343 bool result;
37344 void *argp1 = 0 ;
37345 int res1 = 0 ;
37346 PyObject *swig_obj[1] ;
37347
37348 if (!args) SWIG_fail;
37349 swig_obj[0] = args;
37350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37351 if (!SWIG_IsOK(res1)) {
37352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37353 }
37354 arg1 = reinterpret_cast< wxWindow * >(argp1);
37355 {
37356 PyThreadState* __tstate = wxPyBeginAllowThreads();
37357 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37358 wxPyEndAllowThreads(__tstate);
37359 if (PyErr_Occurred()) SWIG_fail;
37360 }
37361 {
37362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37363 }
37364 return resultobj;
37365 fail:
37366 return NULL;
37367 }
37368
37369
37370 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37371 PyObject *resultobj = 0;
37372 wxWindow *arg1 = (wxWindow *) 0 ;
37373 bool result;
37374 void *argp1 = 0 ;
37375 int res1 = 0 ;
37376 PyObject *swig_obj[1] ;
37377
37378 if (!args) SWIG_fail;
37379 swig_obj[0] = args;
37380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37381 if (!SWIG_IsOK(res1)) {
37382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37383 }
37384 arg1 = reinterpret_cast< wxWindow * >(argp1);
37385 {
37386 PyThreadState* __tstate = wxPyBeginAllowThreads();
37387 result = (bool)(arg1)->Layout();
37388 wxPyEndAllowThreads(__tstate);
37389 if (PyErr_Occurred()) SWIG_fail;
37390 }
37391 {
37392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37393 }
37394 return resultobj;
37395 fail:
37396 return NULL;
37397 }
37398
37399
37400 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37401 PyObject *resultobj = 0;
37402 wxWindow *arg1 = (wxWindow *) 0 ;
37403 wxSizer *arg2 = (wxSizer *) 0 ;
37404 bool arg3 = (bool) true ;
37405 void *argp1 = 0 ;
37406 int res1 = 0 ;
37407 int res2 = 0 ;
37408 bool val3 ;
37409 int ecode3 = 0 ;
37410 PyObject * obj0 = 0 ;
37411 PyObject * obj1 = 0 ;
37412 PyObject * obj2 = 0 ;
37413 char * kwnames[] = {
37414 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37415 };
37416
37417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37419 if (!SWIG_IsOK(res1)) {
37420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37421 }
37422 arg1 = reinterpret_cast< wxWindow * >(argp1);
37423 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37424 if (!SWIG_IsOK(res2)) {
37425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37426 }
37427 if (obj2) {
37428 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37429 if (!SWIG_IsOK(ecode3)) {
37430 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37431 }
37432 arg3 = static_cast< bool >(val3);
37433 }
37434 {
37435 PyThreadState* __tstate = wxPyBeginAllowThreads();
37436 (arg1)->SetSizer(arg2,arg3);
37437 wxPyEndAllowThreads(__tstate);
37438 if (PyErr_Occurred()) SWIG_fail;
37439 }
37440 resultobj = SWIG_Py_Void();
37441 return resultobj;
37442 fail:
37443 return NULL;
37444 }
37445
37446
37447 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37448 PyObject *resultobj = 0;
37449 wxWindow *arg1 = (wxWindow *) 0 ;
37450 wxSizer *arg2 = (wxSizer *) 0 ;
37451 bool arg3 = (bool) true ;
37452 void *argp1 = 0 ;
37453 int res1 = 0 ;
37454 int res2 = 0 ;
37455 bool val3 ;
37456 int ecode3 = 0 ;
37457 PyObject * obj0 = 0 ;
37458 PyObject * obj1 = 0 ;
37459 PyObject * obj2 = 0 ;
37460 char * kwnames[] = {
37461 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37462 };
37463
37464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37466 if (!SWIG_IsOK(res1)) {
37467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37468 }
37469 arg1 = reinterpret_cast< wxWindow * >(argp1);
37470 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37471 if (!SWIG_IsOK(res2)) {
37472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37473 }
37474 if (obj2) {
37475 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37476 if (!SWIG_IsOK(ecode3)) {
37477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37478 }
37479 arg3 = static_cast< bool >(val3);
37480 }
37481 {
37482 PyThreadState* __tstate = wxPyBeginAllowThreads();
37483 (arg1)->SetSizerAndFit(arg2,arg3);
37484 wxPyEndAllowThreads(__tstate);
37485 if (PyErr_Occurred()) SWIG_fail;
37486 }
37487 resultobj = SWIG_Py_Void();
37488 return resultobj;
37489 fail:
37490 return NULL;
37491 }
37492
37493
37494 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37495 PyObject *resultobj = 0;
37496 wxWindow *arg1 = (wxWindow *) 0 ;
37497 wxSizer *result = 0 ;
37498 void *argp1 = 0 ;
37499 int res1 = 0 ;
37500 PyObject *swig_obj[1] ;
37501
37502 if (!args) SWIG_fail;
37503 swig_obj[0] = args;
37504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37505 if (!SWIG_IsOK(res1)) {
37506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37507 }
37508 arg1 = reinterpret_cast< wxWindow * >(argp1);
37509 {
37510 PyThreadState* __tstate = wxPyBeginAllowThreads();
37511 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37512 wxPyEndAllowThreads(__tstate);
37513 if (PyErr_Occurred()) SWIG_fail;
37514 }
37515 {
37516 resultobj = wxPyMake_wxObject(result, (bool)0);
37517 }
37518 return resultobj;
37519 fail:
37520 return NULL;
37521 }
37522
37523
37524 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37525 PyObject *resultobj = 0;
37526 wxWindow *arg1 = (wxWindow *) 0 ;
37527 wxSizer *arg2 = (wxSizer *) 0 ;
37528 void *argp1 = 0 ;
37529 int res1 = 0 ;
37530 void *argp2 = 0 ;
37531 int res2 = 0 ;
37532 PyObject * obj0 = 0 ;
37533 PyObject * obj1 = 0 ;
37534 char * kwnames[] = {
37535 (char *) "self",(char *) "sizer", NULL
37536 };
37537
37538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37540 if (!SWIG_IsOK(res1)) {
37541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37542 }
37543 arg1 = reinterpret_cast< wxWindow * >(argp1);
37544 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37545 if (!SWIG_IsOK(res2)) {
37546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37547 }
37548 arg2 = reinterpret_cast< wxSizer * >(argp2);
37549 {
37550 PyThreadState* __tstate = wxPyBeginAllowThreads();
37551 (arg1)->SetContainingSizer(arg2);
37552 wxPyEndAllowThreads(__tstate);
37553 if (PyErr_Occurred()) SWIG_fail;
37554 }
37555 resultobj = SWIG_Py_Void();
37556 return resultobj;
37557 fail:
37558 return NULL;
37559 }
37560
37561
37562 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37563 PyObject *resultobj = 0;
37564 wxWindow *arg1 = (wxWindow *) 0 ;
37565 wxSizer *result = 0 ;
37566 void *argp1 = 0 ;
37567 int res1 = 0 ;
37568 PyObject *swig_obj[1] ;
37569
37570 if (!args) SWIG_fail;
37571 swig_obj[0] = args;
37572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37573 if (!SWIG_IsOK(res1)) {
37574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37575 }
37576 arg1 = reinterpret_cast< wxWindow * >(argp1);
37577 {
37578 PyThreadState* __tstate = wxPyBeginAllowThreads();
37579 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37580 wxPyEndAllowThreads(__tstate);
37581 if (PyErr_Occurred()) SWIG_fail;
37582 }
37583 {
37584 resultobj = wxPyMake_wxObject(result, (bool)0);
37585 }
37586 return resultobj;
37587 fail:
37588 return NULL;
37589 }
37590
37591
37592 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37593 PyObject *resultobj = 0;
37594 wxWindow *arg1 = (wxWindow *) 0 ;
37595 void *argp1 = 0 ;
37596 int res1 = 0 ;
37597 PyObject *swig_obj[1] ;
37598
37599 if (!args) SWIG_fail;
37600 swig_obj[0] = args;
37601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37602 if (!SWIG_IsOK(res1)) {
37603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37604 }
37605 arg1 = reinterpret_cast< wxWindow * >(argp1);
37606 {
37607 PyThreadState* __tstate = wxPyBeginAllowThreads();
37608 (arg1)->InheritAttributes();
37609 wxPyEndAllowThreads(__tstate);
37610 if (PyErr_Occurred()) SWIG_fail;
37611 }
37612 resultobj = SWIG_Py_Void();
37613 return resultobj;
37614 fail:
37615 return NULL;
37616 }
37617
37618
37619 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37620 PyObject *resultobj = 0;
37621 wxWindow *arg1 = (wxWindow *) 0 ;
37622 bool result;
37623 void *argp1 = 0 ;
37624 int res1 = 0 ;
37625 PyObject *swig_obj[1] ;
37626
37627 if (!args) SWIG_fail;
37628 swig_obj[0] = args;
37629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37630 if (!SWIG_IsOK(res1)) {
37631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37632 }
37633 arg1 = reinterpret_cast< wxWindow * >(argp1);
37634 {
37635 PyThreadState* __tstate = wxPyBeginAllowThreads();
37636 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37637 wxPyEndAllowThreads(__tstate);
37638 if (PyErr_Occurred()) SWIG_fail;
37639 }
37640 {
37641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37642 }
37643 return resultobj;
37644 fail:
37645 return NULL;
37646 }
37647
37648
37649 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37650 PyObject *obj;
37651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37652 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37653 return SWIG_Py_Void();
37654 }
37655
37656 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37657 return SWIG_Python_InitShadowInstance(args);
37658 }
37659
37660 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37661 PyObject *resultobj = 0;
37662 long arg1 ;
37663 wxWindow *arg2 = (wxWindow *) NULL ;
37664 wxWindow *result = 0 ;
37665 long val1 ;
37666 int ecode1 = 0 ;
37667 void *argp2 = 0 ;
37668 int res2 = 0 ;
37669 PyObject * obj0 = 0 ;
37670 PyObject * obj1 = 0 ;
37671 char * kwnames[] = {
37672 (char *) "id",(char *) "parent", NULL
37673 };
37674
37675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37676 ecode1 = SWIG_AsVal_long(obj0, &val1);
37677 if (!SWIG_IsOK(ecode1)) {
37678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37679 }
37680 arg1 = static_cast< long >(val1);
37681 if (obj1) {
37682 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37683 if (!SWIG_IsOK(res2)) {
37684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37685 }
37686 arg2 = reinterpret_cast< wxWindow * >(argp2);
37687 }
37688 {
37689 if (!wxPyCheckForApp()) SWIG_fail;
37690 PyThreadState* __tstate = wxPyBeginAllowThreads();
37691 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37692 wxPyEndAllowThreads(__tstate);
37693 if (PyErr_Occurred()) SWIG_fail;
37694 }
37695 {
37696 resultobj = wxPyMake_wxObject(result, 0);
37697 }
37698 return resultobj;
37699 fail:
37700 return NULL;
37701 }
37702
37703
37704 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37705 PyObject *resultobj = 0;
37706 wxString *arg1 = 0 ;
37707 wxWindow *arg2 = (wxWindow *) NULL ;
37708 wxWindow *result = 0 ;
37709 bool temp1 = false ;
37710 void *argp2 = 0 ;
37711 int res2 = 0 ;
37712 PyObject * obj0 = 0 ;
37713 PyObject * obj1 = 0 ;
37714 char * kwnames[] = {
37715 (char *) "name",(char *) "parent", NULL
37716 };
37717
37718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37719 {
37720 arg1 = wxString_in_helper(obj0);
37721 if (arg1 == NULL) SWIG_fail;
37722 temp1 = true;
37723 }
37724 if (obj1) {
37725 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37726 if (!SWIG_IsOK(res2)) {
37727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37728 }
37729 arg2 = reinterpret_cast< wxWindow * >(argp2);
37730 }
37731 {
37732 if (!wxPyCheckForApp()) SWIG_fail;
37733 PyThreadState* __tstate = wxPyBeginAllowThreads();
37734 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37735 wxPyEndAllowThreads(__tstate);
37736 if (PyErr_Occurred()) SWIG_fail;
37737 }
37738 {
37739 resultobj = wxPyMake_wxObject(result, 0);
37740 }
37741 {
37742 if (temp1)
37743 delete arg1;
37744 }
37745 return resultobj;
37746 fail:
37747 {
37748 if (temp1)
37749 delete arg1;
37750 }
37751 return NULL;
37752 }
37753
37754
37755 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37756 PyObject *resultobj = 0;
37757 wxString *arg1 = 0 ;
37758 wxWindow *arg2 = (wxWindow *) NULL ;
37759 wxWindow *result = 0 ;
37760 bool temp1 = false ;
37761 void *argp2 = 0 ;
37762 int res2 = 0 ;
37763 PyObject * obj0 = 0 ;
37764 PyObject * obj1 = 0 ;
37765 char * kwnames[] = {
37766 (char *) "label",(char *) "parent", NULL
37767 };
37768
37769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37770 {
37771 arg1 = wxString_in_helper(obj0);
37772 if (arg1 == NULL) SWIG_fail;
37773 temp1 = true;
37774 }
37775 if (obj1) {
37776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37777 if (!SWIG_IsOK(res2)) {
37778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37779 }
37780 arg2 = reinterpret_cast< wxWindow * >(argp2);
37781 }
37782 {
37783 if (!wxPyCheckForApp()) SWIG_fail;
37784 PyThreadState* __tstate = wxPyBeginAllowThreads();
37785 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37786 wxPyEndAllowThreads(__tstate);
37787 if (PyErr_Occurred()) SWIG_fail;
37788 }
37789 {
37790 resultobj = wxPyMake_wxObject(result, 0);
37791 }
37792 {
37793 if (temp1)
37794 delete arg1;
37795 }
37796 return resultobj;
37797 fail:
37798 {
37799 if (temp1)
37800 delete arg1;
37801 }
37802 return NULL;
37803 }
37804
37805
37806 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37807 PyObject *resultobj = 0;
37808 wxWindow *arg1 = (wxWindow *) 0 ;
37809 unsigned long arg2 ;
37810 wxWindow *result = 0 ;
37811 void *argp1 = 0 ;
37812 int res1 = 0 ;
37813 unsigned long val2 ;
37814 int ecode2 = 0 ;
37815 PyObject * obj0 = 0 ;
37816 PyObject * obj1 = 0 ;
37817 char * kwnames[] = {
37818 (char *) "parent",(char *) "_hWnd", NULL
37819 };
37820
37821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37823 if (!SWIG_IsOK(res1)) {
37824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37825 }
37826 arg1 = reinterpret_cast< wxWindow * >(argp1);
37827 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37828 if (!SWIG_IsOK(ecode2)) {
37829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37830 }
37831 arg2 = static_cast< unsigned long >(val2);
37832 {
37833 PyThreadState* __tstate = wxPyBeginAllowThreads();
37834 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37835 wxPyEndAllowThreads(__tstate);
37836 if (PyErr_Occurred()) SWIG_fail;
37837 }
37838 {
37839 resultobj = wxPyMake_wxObject(result, 0);
37840 }
37841 return resultobj;
37842 fail:
37843 return NULL;
37844 }
37845
37846
37847 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37848 PyObject *resultobj = 0;
37849 PyObject *result = 0 ;
37850
37851 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37852 {
37853 PyThreadState* __tstate = wxPyBeginAllowThreads();
37854 result = (PyObject *)GetTopLevelWindows();
37855 wxPyEndAllowThreads(__tstate);
37856 if (PyErr_Occurred()) SWIG_fail;
37857 }
37858 resultobj = result;
37859 return resultobj;
37860 fail:
37861 return NULL;
37862 }
37863
37864
37865 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37866 PyObject *resultobj = 0;
37867 wxValidator *result = 0 ;
37868
37869 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37870 {
37871 PyThreadState* __tstate = wxPyBeginAllowThreads();
37872 result = (wxValidator *)new wxValidator();
37873 wxPyEndAllowThreads(__tstate);
37874 if (PyErr_Occurred()) SWIG_fail;
37875 }
37876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37877 return resultobj;
37878 fail:
37879 return NULL;
37880 }
37881
37882
37883 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37884 PyObject *resultobj = 0;
37885 wxValidator *arg1 = (wxValidator *) 0 ;
37886 wxValidator *result = 0 ;
37887 void *argp1 = 0 ;
37888 int res1 = 0 ;
37889 PyObject *swig_obj[1] ;
37890
37891 if (!args) SWIG_fail;
37892 swig_obj[0] = args;
37893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37894 if (!SWIG_IsOK(res1)) {
37895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37896 }
37897 arg1 = reinterpret_cast< wxValidator * >(argp1);
37898 {
37899 PyThreadState* __tstate = wxPyBeginAllowThreads();
37900 result = (wxValidator *)(arg1)->Clone();
37901 wxPyEndAllowThreads(__tstate);
37902 if (PyErr_Occurred()) SWIG_fail;
37903 }
37904 {
37905 resultobj = wxPyMake_wxObject(result, 0);
37906 }
37907 return resultobj;
37908 fail:
37909 return NULL;
37910 }
37911
37912
37913 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37914 PyObject *resultobj = 0;
37915 wxValidator *arg1 = (wxValidator *) 0 ;
37916 wxWindow *arg2 = (wxWindow *) 0 ;
37917 bool result;
37918 void *argp1 = 0 ;
37919 int res1 = 0 ;
37920 void *argp2 = 0 ;
37921 int res2 = 0 ;
37922 PyObject * obj0 = 0 ;
37923 PyObject * obj1 = 0 ;
37924 char * kwnames[] = {
37925 (char *) "self",(char *) "parent", NULL
37926 };
37927
37928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37930 if (!SWIG_IsOK(res1)) {
37931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37932 }
37933 arg1 = reinterpret_cast< wxValidator * >(argp1);
37934 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37935 if (!SWIG_IsOK(res2)) {
37936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37937 }
37938 arg2 = reinterpret_cast< wxWindow * >(argp2);
37939 {
37940 PyThreadState* __tstate = wxPyBeginAllowThreads();
37941 result = (bool)(arg1)->Validate(arg2);
37942 wxPyEndAllowThreads(__tstate);
37943 if (PyErr_Occurred()) SWIG_fail;
37944 }
37945 {
37946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37947 }
37948 return resultobj;
37949 fail:
37950 return NULL;
37951 }
37952
37953
37954 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37955 PyObject *resultobj = 0;
37956 wxValidator *arg1 = (wxValidator *) 0 ;
37957 bool result;
37958 void *argp1 = 0 ;
37959 int res1 = 0 ;
37960 PyObject *swig_obj[1] ;
37961
37962 if (!args) SWIG_fail;
37963 swig_obj[0] = args;
37964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37965 if (!SWIG_IsOK(res1)) {
37966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37967 }
37968 arg1 = reinterpret_cast< wxValidator * >(argp1);
37969 {
37970 PyThreadState* __tstate = wxPyBeginAllowThreads();
37971 result = (bool)(arg1)->TransferToWindow();
37972 wxPyEndAllowThreads(__tstate);
37973 if (PyErr_Occurred()) SWIG_fail;
37974 }
37975 {
37976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37977 }
37978 return resultobj;
37979 fail:
37980 return NULL;
37981 }
37982
37983
37984 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37985 PyObject *resultobj = 0;
37986 wxValidator *arg1 = (wxValidator *) 0 ;
37987 bool result;
37988 void *argp1 = 0 ;
37989 int res1 = 0 ;
37990 PyObject *swig_obj[1] ;
37991
37992 if (!args) SWIG_fail;
37993 swig_obj[0] = args;
37994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37995 if (!SWIG_IsOK(res1)) {
37996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37997 }
37998 arg1 = reinterpret_cast< wxValidator * >(argp1);
37999 {
38000 PyThreadState* __tstate = wxPyBeginAllowThreads();
38001 result = (bool)(arg1)->TransferFromWindow();
38002 wxPyEndAllowThreads(__tstate);
38003 if (PyErr_Occurred()) SWIG_fail;
38004 }
38005 {
38006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38007 }
38008 return resultobj;
38009 fail:
38010 return NULL;
38011 }
38012
38013
38014 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38015 PyObject *resultobj = 0;
38016 wxValidator *arg1 = (wxValidator *) 0 ;
38017 wxWindow *result = 0 ;
38018 void *argp1 = 0 ;
38019 int res1 = 0 ;
38020 PyObject *swig_obj[1] ;
38021
38022 if (!args) SWIG_fail;
38023 swig_obj[0] = args;
38024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38025 if (!SWIG_IsOK(res1)) {
38026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38027 }
38028 arg1 = reinterpret_cast< wxValidator * >(argp1);
38029 {
38030 PyThreadState* __tstate = wxPyBeginAllowThreads();
38031 result = (wxWindow *)(arg1)->GetWindow();
38032 wxPyEndAllowThreads(__tstate);
38033 if (PyErr_Occurred()) SWIG_fail;
38034 }
38035 {
38036 resultobj = wxPyMake_wxObject(result, 0);
38037 }
38038 return resultobj;
38039 fail:
38040 return NULL;
38041 }
38042
38043
38044 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38045 PyObject *resultobj = 0;
38046 wxValidator *arg1 = (wxValidator *) 0 ;
38047 wxWindow *arg2 = (wxWindow *) 0 ;
38048 void *argp1 = 0 ;
38049 int res1 = 0 ;
38050 void *argp2 = 0 ;
38051 int res2 = 0 ;
38052 PyObject * obj0 = 0 ;
38053 PyObject * obj1 = 0 ;
38054 char * kwnames[] = {
38055 (char *) "self",(char *) "window", NULL
38056 };
38057
38058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38060 if (!SWIG_IsOK(res1)) {
38061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38062 }
38063 arg1 = reinterpret_cast< wxValidator * >(argp1);
38064 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38065 if (!SWIG_IsOK(res2)) {
38066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38067 }
38068 arg2 = reinterpret_cast< wxWindow * >(argp2);
38069 {
38070 PyThreadState* __tstate = wxPyBeginAllowThreads();
38071 (arg1)->SetWindow(arg2);
38072 wxPyEndAllowThreads(__tstate);
38073 if (PyErr_Occurred()) SWIG_fail;
38074 }
38075 resultobj = SWIG_Py_Void();
38076 return resultobj;
38077 fail:
38078 return NULL;
38079 }
38080
38081
38082 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38083 PyObject *resultobj = 0;
38084 bool result;
38085
38086 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38087 {
38088 PyThreadState* __tstate = wxPyBeginAllowThreads();
38089 result = (bool)wxValidator::IsSilent();
38090 wxPyEndAllowThreads(__tstate);
38091 if (PyErr_Occurred()) SWIG_fail;
38092 }
38093 {
38094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38095 }
38096 return resultobj;
38097 fail:
38098 return NULL;
38099 }
38100
38101
38102 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38103 PyObject *resultobj = 0;
38104 int arg1 = (int) true ;
38105 int val1 ;
38106 int ecode1 = 0 ;
38107 PyObject * obj0 = 0 ;
38108 char * kwnames[] = {
38109 (char *) "doIt", NULL
38110 };
38111
38112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38113 if (obj0) {
38114 ecode1 = SWIG_AsVal_int(obj0, &val1);
38115 if (!SWIG_IsOK(ecode1)) {
38116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38117 }
38118 arg1 = static_cast< int >(val1);
38119 }
38120 {
38121 PyThreadState* __tstate = wxPyBeginAllowThreads();
38122 wxValidator::SetBellOnError(arg1);
38123 wxPyEndAllowThreads(__tstate);
38124 if (PyErr_Occurred()) SWIG_fail;
38125 }
38126 resultobj = SWIG_Py_Void();
38127 return resultobj;
38128 fail:
38129 return NULL;
38130 }
38131
38132
38133 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38134 PyObject *obj;
38135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38136 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38137 return SWIG_Py_Void();
38138 }
38139
38140 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38141 return SWIG_Python_InitShadowInstance(args);
38142 }
38143
38144 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38145 PyObject *resultobj = 0;
38146 wxPyValidator *result = 0 ;
38147
38148 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38149 {
38150 PyThreadState* __tstate = wxPyBeginAllowThreads();
38151 result = (wxPyValidator *)new wxPyValidator();
38152 wxPyEndAllowThreads(__tstate);
38153 if (PyErr_Occurred()) SWIG_fail;
38154 }
38155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38156 return resultobj;
38157 fail:
38158 return NULL;
38159 }
38160
38161
38162 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38163 PyObject *resultobj = 0;
38164 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38165 PyObject *arg2 = (PyObject *) 0 ;
38166 PyObject *arg3 = (PyObject *) 0 ;
38167 int arg4 = (int) true ;
38168 void *argp1 = 0 ;
38169 int res1 = 0 ;
38170 int val4 ;
38171 int ecode4 = 0 ;
38172 PyObject * obj0 = 0 ;
38173 PyObject * obj1 = 0 ;
38174 PyObject * obj2 = 0 ;
38175 PyObject * obj3 = 0 ;
38176 char * kwnames[] = {
38177 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38178 };
38179
38180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38182 if (!SWIG_IsOK(res1)) {
38183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38184 }
38185 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38186 arg2 = obj1;
38187 arg3 = obj2;
38188 if (obj3) {
38189 ecode4 = SWIG_AsVal_int(obj3, &val4);
38190 if (!SWIG_IsOK(ecode4)) {
38191 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38192 }
38193 arg4 = static_cast< int >(val4);
38194 }
38195 {
38196 PyThreadState* __tstate = wxPyBeginAllowThreads();
38197 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38198 wxPyEndAllowThreads(__tstate);
38199 if (PyErr_Occurred()) SWIG_fail;
38200 }
38201 resultobj = SWIG_Py_Void();
38202 return resultobj;
38203 fail:
38204 return NULL;
38205 }
38206
38207
38208 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38209 PyObject *obj;
38210 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38211 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38212 return SWIG_Py_Void();
38213 }
38214
38215 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38216 return SWIG_Python_InitShadowInstance(args);
38217 }
38218
38219 SWIGINTERN int DefaultValidator_set(PyObject *) {
38220 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38221 return 1;
38222 }
38223
38224
38225 SWIGINTERN PyObject *DefaultValidator_get(void) {
38226 PyObject *pyobj = 0;
38227
38228 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38229 return pyobj;
38230 }
38231
38232
38233 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38234 PyObject *resultobj = 0;
38235 wxString const &arg1_defvalue = wxPyEmptyString ;
38236 wxString *arg1 = (wxString *) &arg1_defvalue ;
38237 long arg2 = (long) 0 ;
38238 wxMenu *result = 0 ;
38239 bool temp1 = false ;
38240 long val2 ;
38241 int ecode2 = 0 ;
38242 PyObject * obj0 = 0 ;
38243 PyObject * obj1 = 0 ;
38244 char * kwnames[] = {
38245 (char *) "title",(char *) "style", NULL
38246 };
38247
38248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38249 if (obj0) {
38250 {
38251 arg1 = wxString_in_helper(obj0);
38252 if (arg1 == NULL) SWIG_fail;
38253 temp1 = true;
38254 }
38255 }
38256 if (obj1) {
38257 ecode2 = SWIG_AsVal_long(obj1, &val2);
38258 if (!SWIG_IsOK(ecode2)) {
38259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38260 }
38261 arg2 = static_cast< long >(val2);
38262 }
38263 {
38264 if (!wxPyCheckForApp()) SWIG_fail;
38265 PyThreadState* __tstate = wxPyBeginAllowThreads();
38266 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38267 wxPyEndAllowThreads(__tstate);
38268 if (PyErr_Occurred()) SWIG_fail;
38269 }
38270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38271 {
38272 if (temp1)
38273 delete arg1;
38274 }
38275 return resultobj;
38276 fail:
38277 {
38278 if (temp1)
38279 delete arg1;
38280 }
38281 return NULL;
38282 }
38283
38284
38285 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38286 PyObject *resultobj = 0;
38287 wxMenu *arg1 = (wxMenu *) 0 ;
38288 int arg2 ;
38289 wxString *arg3 = 0 ;
38290 wxString const &arg4_defvalue = wxPyEmptyString ;
38291 wxString *arg4 = (wxString *) &arg4_defvalue ;
38292 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38293 wxMenuItem *result = 0 ;
38294 void *argp1 = 0 ;
38295 int res1 = 0 ;
38296 int val2 ;
38297 int ecode2 = 0 ;
38298 bool temp3 = false ;
38299 bool temp4 = false ;
38300 int val5 ;
38301 int ecode5 = 0 ;
38302 PyObject * obj0 = 0 ;
38303 PyObject * obj1 = 0 ;
38304 PyObject * obj2 = 0 ;
38305 PyObject * obj3 = 0 ;
38306 PyObject * obj4 = 0 ;
38307 char * kwnames[] = {
38308 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38309 };
38310
38311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38313 if (!SWIG_IsOK(res1)) {
38314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38315 }
38316 arg1 = reinterpret_cast< wxMenu * >(argp1);
38317 ecode2 = SWIG_AsVal_int(obj1, &val2);
38318 if (!SWIG_IsOK(ecode2)) {
38319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38320 }
38321 arg2 = static_cast< int >(val2);
38322 {
38323 arg3 = wxString_in_helper(obj2);
38324 if (arg3 == NULL) SWIG_fail;
38325 temp3 = true;
38326 }
38327 if (obj3) {
38328 {
38329 arg4 = wxString_in_helper(obj3);
38330 if (arg4 == NULL) SWIG_fail;
38331 temp4 = true;
38332 }
38333 }
38334 if (obj4) {
38335 ecode5 = SWIG_AsVal_int(obj4, &val5);
38336 if (!SWIG_IsOK(ecode5)) {
38337 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38338 }
38339 arg5 = static_cast< wxItemKind >(val5);
38340 }
38341 {
38342 PyThreadState* __tstate = wxPyBeginAllowThreads();
38343 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38344 wxPyEndAllowThreads(__tstate);
38345 if (PyErr_Occurred()) SWIG_fail;
38346 }
38347 {
38348 resultobj = wxPyMake_wxObject(result, (bool)0);
38349 }
38350 {
38351 if (temp3)
38352 delete arg3;
38353 }
38354 {
38355 if (temp4)
38356 delete arg4;
38357 }
38358 return resultobj;
38359 fail:
38360 {
38361 if (temp3)
38362 delete arg3;
38363 }
38364 {
38365 if (temp4)
38366 delete arg4;
38367 }
38368 return NULL;
38369 }
38370
38371
38372 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38373 PyObject *resultobj = 0;
38374 wxMenu *arg1 = (wxMenu *) 0 ;
38375 wxMenuItem *result = 0 ;
38376 void *argp1 = 0 ;
38377 int res1 = 0 ;
38378 PyObject *swig_obj[1] ;
38379
38380 if (!args) SWIG_fail;
38381 swig_obj[0] = args;
38382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38383 if (!SWIG_IsOK(res1)) {
38384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38385 }
38386 arg1 = reinterpret_cast< wxMenu * >(argp1);
38387 {
38388 PyThreadState* __tstate = wxPyBeginAllowThreads();
38389 result = (wxMenuItem *)(arg1)->AppendSeparator();
38390 wxPyEndAllowThreads(__tstate);
38391 if (PyErr_Occurred()) SWIG_fail;
38392 }
38393 {
38394 resultobj = wxPyMake_wxObject(result, (bool)0);
38395 }
38396 return resultobj;
38397 fail:
38398 return NULL;
38399 }
38400
38401
38402 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38403 PyObject *resultobj = 0;
38404 wxMenu *arg1 = (wxMenu *) 0 ;
38405 int arg2 ;
38406 wxString *arg3 = 0 ;
38407 wxString const &arg4_defvalue = wxPyEmptyString ;
38408 wxString *arg4 = (wxString *) &arg4_defvalue ;
38409 wxMenuItem *result = 0 ;
38410 void *argp1 = 0 ;
38411 int res1 = 0 ;
38412 int val2 ;
38413 int ecode2 = 0 ;
38414 bool temp3 = false ;
38415 bool temp4 = false ;
38416 PyObject * obj0 = 0 ;
38417 PyObject * obj1 = 0 ;
38418 PyObject * obj2 = 0 ;
38419 PyObject * obj3 = 0 ;
38420 char * kwnames[] = {
38421 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38422 };
38423
38424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38426 if (!SWIG_IsOK(res1)) {
38427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38428 }
38429 arg1 = reinterpret_cast< wxMenu * >(argp1);
38430 ecode2 = SWIG_AsVal_int(obj1, &val2);
38431 if (!SWIG_IsOK(ecode2)) {
38432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38433 }
38434 arg2 = static_cast< int >(val2);
38435 {
38436 arg3 = wxString_in_helper(obj2);
38437 if (arg3 == NULL) SWIG_fail;
38438 temp3 = true;
38439 }
38440 if (obj3) {
38441 {
38442 arg4 = wxString_in_helper(obj3);
38443 if (arg4 == NULL) SWIG_fail;
38444 temp4 = true;
38445 }
38446 }
38447 {
38448 PyThreadState* __tstate = wxPyBeginAllowThreads();
38449 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38450 wxPyEndAllowThreads(__tstate);
38451 if (PyErr_Occurred()) SWIG_fail;
38452 }
38453 {
38454 resultobj = wxPyMake_wxObject(result, (bool)0);
38455 }
38456 {
38457 if (temp3)
38458 delete arg3;
38459 }
38460 {
38461 if (temp4)
38462 delete arg4;
38463 }
38464 return resultobj;
38465 fail:
38466 {
38467 if (temp3)
38468 delete arg3;
38469 }
38470 {
38471 if (temp4)
38472 delete arg4;
38473 }
38474 return NULL;
38475 }
38476
38477
38478 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38479 PyObject *resultobj = 0;
38480 wxMenu *arg1 = (wxMenu *) 0 ;
38481 int arg2 ;
38482 wxString *arg3 = 0 ;
38483 wxString const &arg4_defvalue = wxPyEmptyString ;
38484 wxString *arg4 = (wxString *) &arg4_defvalue ;
38485 wxMenuItem *result = 0 ;
38486 void *argp1 = 0 ;
38487 int res1 = 0 ;
38488 int val2 ;
38489 int ecode2 = 0 ;
38490 bool temp3 = false ;
38491 bool temp4 = false ;
38492 PyObject * obj0 = 0 ;
38493 PyObject * obj1 = 0 ;
38494 PyObject * obj2 = 0 ;
38495 PyObject * obj3 = 0 ;
38496 char * kwnames[] = {
38497 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38498 };
38499
38500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38502 if (!SWIG_IsOK(res1)) {
38503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38504 }
38505 arg1 = reinterpret_cast< wxMenu * >(argp1);
38506 ecode2 = SWIG_AsVal_int(obj1, &val2);
38507 if (!SWIG_IsOK(ecode2)) {
38508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38509 }
38510 arg2 = static_cast< int >(val2);
38511 {
38512 arg3 = wxString_in_helper(obj2);
38513 if (arg3 == NULL) SWIG_fail;
38514 temp3 = true;
38515 }
38516 if (obj3) {
38517 {
38518 arg4 = wxString_in_helper(obj3);
38519 if (arg4 == NULL) SWIG_fail;
38520 temp4 = true;
38521 }
38522 }
38523 {
38524 PyThreadState* __tstate = wxPyBeginAllowThreads();
38525 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38526 wxPyEndAllowThreads(__tstate);
38527 if (PyErr_Occurred()) SWIG_fail;
38528 }
38529 {
38530 resultobj = wxPyMake_wxObject(result, (bool)0);
38531 }
38532 {
38533 if (temp3)
38534 delete arg3;
38535 }
38536 {
38537 if (temp4)
38538 delete arg4;
38539 }
38540 return resultobj;
38541 fail:
38542 {
38543 if (temp3)
38544 delete arg3;
38545 }
38546 {
38547 if (temp4)
38548 delete arg4;
38549 }
38550 return NULL;
38551 }
38552
38553
38554 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38555 PyObject *resultobj = 0;
38556 wxMenu *arg1 = (wxMenu *) 0 ;
38557 int arg2 ;
38558 wxString *arg3 = 0 ;
38559 wxMenu *arg4 = (wxMenu *) 0 ;
38560 wxString const &arg5_defvalue = wxPyEmptyString ;
38561 wxString *arg5 = (wxString *) &arg5_defvalue ;
38562 wxMenuItem *result = 0 ;
38563 void *argp1 = 0 ;
38564 int res1 = 0 ;
38565 int val2 ;
38566 int ecode2 = 0 ;
38567 bool temp3 = false ;
38568 void *argp4 = 0 ;
38569 int res4 = 0 ;
38570 bool temp5 = false ;
38571 PyObject * obj0 = 0 ;
38572 PyObject * obj1 = 0 ;
38573 PyObject * obj2 = 0 ;
38574 PyObject * obj3 = 0 ;
38575 PyObject * obj4 = 0 ;
38576 char * kwnames[] = {
38577 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38578 };
38579
38580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38582 if (!SWIG_IsOK(res1)) {
38583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38584 }
38585 arg1 = reinterpret_cast< wxMenu * >(argp1);
38586 ecode2 = SWIG_AsVal_int(obj1, &val2);
38587 if (!SWIG_IsOK(ecode2)) {
38588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38589 }
38590 arg2 = static_cast< int >(val2);
38591 {
38592 arg3 = wxString_in_helper(obj2);
38593 if (arg3 == NULL) SWIG_fail;
38594 temp3 = true;
38595 }
38596 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38597 if (!SWIG_IsOK(res4)) {
38598 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38599 }
38600 arg4 = reinterpret_cast< wxMenu * >(argp4);
38601 if (obj4) {
38602 {
38603 arg5 = wxString_in_helper(obj4);
38604 if (arg5 == NULL) SWIG_fail;
38605 temp5 = true;
38606 }
38607 }
38608 {
38609 PyThreadState* __tstate = wxPyBeginAllowThreads();
38610 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38611 wxPyEndAllowThreads(__tstate);
38612 if (PyErr_Occurred()) SWIG_fail;
38613 }
38614 {
38615 resultobj = wxPyMake_wxObject(result, (bool)0);
38616 }
38617 {
38618 if (temp3)
38619 delete arg3;
38620 }
38621 {
38622 if (temp5)
38623 delete arg5;
38624 }
38625 return resultobj;
38626 fail:
38627 {
38628 if (temp3)
38629 delete arg3;
38630 }
38631 {
38632 if (temp5)
38633 delete arg5;
38634 }
38635 return NULL;
38636 }
38637
38638
38639 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38640 PyObject *resultobj = 0;
38641 wxMenu *arg1 = (wxMenu *) 0 ;
38642 wxMenu *arg2 = (wxMenu *) 0 ;
38643 wxString *arg3 = 0 ;
38644 wxString const &arg4_defvalue = wxPyEmptyString ;
38645 wxString *arg4 = (wxString *) &arg4_defvalue ;
38646 wxMenuItem *result = 0 ;
38647 void *argp1 = 0 ;
38648 int res1 = 0 ;
38649 void *argp2 = 0 ;
38650 int res2 = 0 ;
38651 bool temp3 = false ;
38652 bool temp4 = false ;
38653 PyObject * obj0 = 0 ;
38654 PyObject * obj1 = 0 ;
38655 PyObject * obj2 = 0 ;
38656 PyObject * obj3 = 0 ;
38657 char * kwnames[] = {
38658 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38659 };
38660
38661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38663 if (!SWIG_IsOK(res1)) {
38664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38665 }
38666 arg1 = reinterpret_cast< wxMenu * >(argp1);
38667 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38668 if (!SWIG_IsOK(res2)) {
38669 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38670 }
38671 arg2 = reinterpret_cast< wxMenu * >(argp2);
38672 {
38673 arg3 = wxString_in_helper(obj2);
38674 if (arg3 == NULL) SWIG_fail;
38675 temp3 = true;
38676 }
38677 if (obj3) {
38678 {
38679 arg4 = wxString_in_helper(obj3);
38680 if (arg4 == NULL) SWIG_fail;
38681 temp4 = true;
38682 }
38683 }
38684 {
38685 PyThreadState* __tstate = wxPyBeginAllowThreads();
38686 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38687 wxPyEndAllowThreads(__tstate);
38688 if (PyErr_Occurred()) SWIG_fail;
38689 }
38690 {
38691 resultobj = wxPyMake_wxObject(result, (bool)0);
38692 }
38693 {
38694 if (temp3)
38695 delete arg3;
38696 }
38697 {
38698 if (temp4)
38699 delete arg4;
38700 }
38701 return resultobj;
38702 fail:
38703 {
38704 if (temp3)
38705 delete arg3;
38706 }
38707 {
38708 if (temp4)
38709 delete arg4;
38710 }
38711 return NULL;
38712 }
38713
38714
38715 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38716 PyObject *resultobj = 0;
38717 wxMenu *arg1 = (wxMenu *) 0 ;
38718 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38719 wxMenuItem *result = 0 ;
38720 void *argp1 = 0 ;
38721 int res1 = 0 ;
38722 int res2 = 0 ;
38723 PyObject * obj0 = 0 ;
38724 PyObject * obj1 = 0 ;
38725 char * kwnames[] = {
38726 (char *) "self",(char *) "item", NULL
38727 };
38728
38729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38731 if (!SWIG_IsOK(res1)) {
38732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38733 }
38734 arg1 = reinterpret_cast< wxMenu * >(argp1);
38735 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38736 if (!SWIG_IsOK(res2)) {
38737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38738 }
38739 {
38740 PyThreadState* __tstate = wxPyBeginAllowThreads();
38741 result = (wxMenuItem *)(arg1)->Append(arg2);
38742 wxPyEndAllowThreads(__tstate);
38743 if (PyErr_Occurred()) SWIG_fail;
38744 }
38745 {
38746 resultobj = wxPyMake_wxObject(result, (bool)0);
38747 }
38748 return resultobj;
38749 fail:
38750 return NULL;
38751 }
38752
38753
38754 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38755 PyObject *resultobj = 0;
38756 wxMenu *arg1 = (wxMenu *) 0 ;
38757 size_t arg2 ;
38758 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38759 wxMenuItem *result = 0 ;
38760 void *argp1 = 0 ;
38761 int res1 = 0 ;
38762 size_t val2 ;
38763 int ecode2 = 0 ;
38764 int res3 = 0 ;
38765 PyObject * obj0 = 0 ;
38766 PyObject * obj1 = 0 ;
38767 PyObject * obj2 = 0 ;
38768 char * kwnames[] = {
38769 (char *) "self",(char *) "pos",(char *) "item", NULL
38770 };
38771
38772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38774 if (!SWIG_IsOK(res1)) {
38775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38776 }
38777 arg1 = reinterpret_cast< wxMenu * >(argp1);
38778 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38779 if (!SWIG_IsOK(ecode2)) {
38780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38781 }
38782 arg2 = static_cast< size_t >(val2);
38783 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38784 if (!SWIG_IsOK(res3)) {
38785 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38786 }
38787 {
38788 PyThreadState* __tstate = wxPyBeginAllowThreads();
38789 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38790 wxPyEndAllowThreads(__tstate);
38791 if (PyErr_Occurred()) SWIG_fail;
38792 }
38793 {
38794 resultobj = wxPyMake_wxObject(result, (bool)0);
38795 }
38796 return resultobj;
38797 fail:
38798 return NULL;
38799 }
38800
38801
38802 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38803 PyObject *resultobj = 0;
38804 wxMenu *arg1 = (wxMenu *) 0 ;
38805 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38806 wxMenuItem *result = 0 ;
38807 void *argp1 = 0 ;
38808 int res1 = 0 ;
38809 int res2 = 0 ;
38810 PyObject * obj0 = 0 ;
38811 PyObject * obj1 = 0 ;
38812 char * kwnames[] = {
38813 (char *) "self",(char *) "item", NULL
38814 };
38815
38816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38818 if (!SWIG_IsOK(res1)) {
38819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38820 }
38821 arg1 = reinterpret_cast< wxMenu * >(argp1);
38822 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38823 if (!SWIG_IsOK(res2)) {
38824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38825 }
38826 {
38827 PyThreadState* __tstate = wxPyBeginAllowThreads();
38828 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38829 wxPyEndAllowThreads(__tstate);
38830 if (PyErr_Occurred()) SWIG_fail;
38831 }
38832 {
38833 resultobj = wxPyMake_wxObject(result, (bool)0);
38834 }
38835 return resultobj;
38836 fail:
38837 return NULL;
38838 }
38839
38840
38841 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38842 PyObject *resultobj = 0;
38843 wxMenu *arg1 = (wxMenu *) 0 ;
38844 void *argp1 = 0 ;
38845 int res1 = 0 ;
38846 PyObject *swig_obj[1] ;
38847
38848 if (!args) SWIG_fail;
38849 swig_obj[0] = args;
38850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38851 if (!SWIG_IsOK(res1)) {
38852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38853 }
38854 arg1 = reinterpret_cast< wxMenu * >(argp1);
38855 {
38856 PyThreadState* __tstate = wxPyBeginAllowThreads();
38857 (arg1)->Break();
38858 wxPyEndAllowThreads(__tstate);
38859 if (PyErr_Occurred()) SWIG_fail;
38860 }
38861 resultobj = SWIG_Py_Void();
38862 return resultobj;
38863 fail:
38864 return NULL;
38865 }
38866
38867
38868 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38869 PyObject *resultobj = 0;
38870 wxMenu *arg1 = (wxMenu *) 0 ;
38871 size_t arg2 ;
38872 int arg3 ;
38873 wxString *arg4 = 0 ;
38874 wxString const &arg5_defvalue = wxPyEmptyString ;
38875 wxString *arg5 = (wxString *) &arg5_defvalue ;
38876 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38877 wxMenuItem *result = 0 ;
38878 void *argp1 = 0 ;
38879 int res1 = 0 ;
38880 size_t val2 ;
38881 int ecode2 = 0 ;
38882 int val3 ;
38883 int ecode3 = 0 ;
38884 bool temp4 = false ;
38885 bool temp5 = false ;
38886 int val6 ;
38887 int ecode6 = 0 ;
38888 PyObject * obj0 = 0 ;
38889 PyObject * obj1 = 0 ;
38890 PyObject * obj2 = 0 ;
38891 PyObject * obj3 = 0 ;
38892 PyObject * obj4 = 0 ;
38893 PyObject * obj5 = 0 ;
38894 char * kwnames[] = {
38895 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38896 };
38897
38898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38900 if (!SWIG_IsOK(res1)) {
38901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38902 }
38903 arg1 = reinterpret_cast< wxMenu * >(argp1);
38904 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38905 if (!SWIG_IsOK(ecode2)) {
38906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38907 }
38908 arg2 = static_cast< size_t >(val2);
38909 ecode3 = SWIG_AsVal_int(obj2, &val3);
38910 if (!SWIG_IsOK(ecode3)) {
38911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38912 }
38913 arg3 = static_cast< int >(val3);
38914 {
38915 arg4 = wxString_in_helper(obj3);
38916 if (arg4 == NULL) SWIG_fail;
38917 temp4 = true;
38918 }
38919 if (obj4) {
38920 {
38921 arg5 = wxString_in_helper(obj4);
38922 if (arg5 == NULL) SWIG_fail;
38923 temp5 = true;
38924 }
38925 }
38926 if (obj5) {
38927 ecode6 = SWIG_AsVal_int(obj5, &val6);
38928 if (!SWIG_IsOK(ecode6)) {
38929 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38930 }
38931 arg6 = static_cast< wxItemKind >(val6);
38932 }
38933 {
38934 PyThreadState* __tstate = wxPyBeginAllowThreads();
38935 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38936 wxPyEndAllowThreads(__tstate);
38937 if (PyErr_Occurred()) SWIG_fail;
38938 }
38939 {
38940 resultobj = wxPyMake_wxObject(result, (bool)0);
38941 }
38942 {
38943 if (temp4)
38944 delete arg4;
38945 }
38946 {
38947 if (temp5)
38948 delete arg5;
38949 }
38950 return resultobj;
38951 fail:
38952 {
38953 if (temp4)
38954 delete arg4;
38955 }
38956 {
38957 if (temp5)
38958 delete arg5;
38959 }
38960 return NULL;
38961 }
38962
38963
38964 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38965 PyObject *resultobj = 0;
38966 wxMenu *arg1 = (wxMenu *) 0 ;
38967 size_t arg2 ;
38968 wxMenuItem *result = 0 ;
38969 void *argp1 = 0 ;
38970 int res1 = 0 ;
38971 size_t val2 ;
38972 int ecode2 = 0 ;
38973 PyObject * obj0 = 0 ;
38974 PyObject * obj1 = 0 ;
38975 char * kwnames[] = {
38976 (char *) "self",(char *) "pos", NULL
38977 };
38978
38979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38981 if (!SWIG_IsOK(res1)) {
38982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38983 }
38984 arg1 = reinterpret_cast< wxMenu * >(argp1);
38985 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38986 if (!SWIG_IsOK(ecode2)) {
38987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38988 }
38989 arg2 = static_cast< size_t >(val2);
38990 {
38991 PyThreadState* __tstate = wxPyBeginAllowThreads();
38992 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38993 wxPyEndAllowThreads(__tstate);
38994 if (PyErr_Occurred()) SWIG_fail;
38995 }
38996 {
38997 resultobj = wxPyMake_wxObject(result, (bool)0);
38998 }
38999 return resultobj;
39000 fail:
39001 return NULL;
39002 }
39003
39004
39005 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39006 PyObject *resultobj = 0;
39007 wxMenu *arg1 = (wxMenu *) 0 ;
39008 size_t arg2 ;
39009 int arg3 ;
39010 wxString *arg4 = 0 ;
39011 wxString const &arg5_defvalue = wxPyEmptyString ;
39012 wxString *arg5 = (wxString *) &arg5_defvalue ;
39013 wxMenuItem *result = 0 ;
39014 void *argp1 = 0 ;
39015 int res1 = 0 ;
39016 size_t val2 ;
39017 int ecode2 = 0 ;
39018 int val3 ;
39019 int ecode3 = 0 ;
39020 bool temp4 = false ;
39021 bool temp5 = false ;
39022 PyObject * obj0 = 0 ;
39023 PyObject * obj1 = 0 ;
39024 PyObject * obj2 = 0 ;
39025 PyObject * obj3 = 0 ;
39026 PyObject * obj4 = 0 ;
39027 char * kwnames[] = {
39028 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39029 };
39030
39031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39033 if (!SWIG_IsOK(res1)) {
39034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39035 }
39036 arg1 = reinterpret_cast< wxMenu * >(argp1);
39037 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39038 if (!SWIG_IsOK(ecode2)) {
39039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39040 }
39041 arg2 = static_cast< size_t >(val2);
39042 ecode3 = SWIG_AsVal_int(obj2, &val3);
39043 if (!SWIG_IsOK(ecode3)) {
39044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39045 }
39046 arg3 = static_cast< int >(val3);
39047 {
39048 arg4 = wxString_in_helper(obj3);
39049 if (arg4 == NULL) SWIG_fail;
39050 temp4 = true;
39051 }
39052 if (obj4) {
39053 {
39054 arg5 = wxString_in_helper(obj4);
39055 if (arg5 == NULL) SWIG_fail;
39056 temp5 = true;
39057 }
39058 }
39059 {
39060 PyThreadState* __tstate = wxPyBeginAllowThreads();
39061 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39062 wxPyEndAllowThreads(__tstate);
39063 if (PyErr_Occurred()) SWIG_fail;
39064 }
39065 {
39066 resultobj = wxPyMake_wxObject(result, (bool)0);
39067 }
39068 {
39069 if (temp4)
39070 delete arg4;
39071 }
39072 {
39073 if (temp5)
39074 delete arg5;
39075 }
39076 return resultobj;
39077 fail:
39078 {
39079 if (temp4)
39080 delete arg4;
39081 }
39082 {
39083 if (temp5)
39084 delete arg5;
39085 }
39086 return NULL;
39087 }
39088
39089
39090 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39091 PyObject *resultobj = 0;
39092 wxMenu *arg1 = (wxMenu *) 0 ;
39093 size_t arg2 ;
39094 int arg3 ;
39095 wxString *arg4 = 0 ;
39096 wxString const &arg5_defvalue = wxPyEmptyString ;
39097 wxString *arg5 = (wxString *) &arg5_defvalue ;
39098 wxMenuItem *result = 0 ;
39099 void *argp1 = 0 ;
39100 int res1 = 0 ;
39101 size_t val2 ;
39102 int ecode2 = 0 ;
39103 int val3 ;
39104 int ecode3 = 0 ;
39105 bool temp4 = false ;
39106 bool temp5 = false ;
39107 PyObject * obj0 = 0 ;
39108 PyObject * obj1 = 0 ;
39109 PyObject * obj2 = 0 ;
39110 PyObject * obj3 = 0 ;
39111 PyObject * obj4 = 0 ;
39112 char * kwnames[] = {
39113 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39114 };
39115
39116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39118 if (!SWIG_IsOK(res1)) {
39119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39120 }
39121 arg1 = reinterpret_cast< wxMenu * >(argp1);
39122 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39123 if (!SWIG_IsOK(ecode2)) {
39124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39125 }
39126 arg2 = static_cast< size_t >(val2);
39127 ecode3 = SWIG_AsVal_int(obj2, &val3);
39128 if (!SWIG_IsOK(ecode3)) {
39129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39130 }
39131 arg3 = static_cast< int >(val3);
39132 {
39133 arg4 = wxString_in_helper(obj3);
39134 if (arg4 == NULL) SWIG_fail;
39135 temp4 = true;
39136 }
39137 if (obj4) {
39138 {
39139 arg5 = wxString_in_helper(obj4);
39140 if (arg5 == NULL) SWIG_fail;
39141 temp5 = true;
39142 }
39143 }
39144 {
39145 PyThreadState* __tstate = wxPyBeginAllowThreads();
39146 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39147 wxPyEndAllowThreads(__tstate);
39148 if (PyErr_Occurred()) SWIG_fail;
39149 }
39150 {
39151 resultobj = wxPyMake_wxObject(result, (bool)0);
39152 }
39153 {
39154 if (temp4)
39155 delete arg4;
39156 }
39157 {
39158 if (temp5)
39159 delete arg5;
39160 }
39161 return resultobj;
39162 fail:
39163 {
39164 if (temp4)
39165 delete arg4;
39166 }
39167 {
39168 if (temp5)
39169 delete arg5;
39170 }
39171 return NULL;
39172 }
39173
39174
39175 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39176 PyObject *resultobj = 0;
39177 wxMenu *arg1 = (wxMenu *) 0 ;
39178 size_t arg2 ;
39179 int arg3 ;
39180 wxString *arg4 = 0 ;
39181 wxMenu *arg5 = (wxMenu *) 0 ;
39182 wxString const &arg6_defvalue = wxPyEmptyString ;
39183 wxString *arg6 = (wxString *) &arg6_defvalue ;
39184 wxMenuItem *result = 0 ;
39185 void *argp1 = 0 ;
39186 int res1 = 0 ;
39187 size_t val2 ;
39188 int ecode2 = 0 ;
39189 int val3 ;
39190 int ecode3 = 0 ;
39191 bool temp4 = false ;
39192 void *argp5 = 0 ;
39193 int res5 = 0 ;
39194 bool temp6 = false ;
39195 PyObject * obj0 = 0 ;
39196 PyObject * obj1 = 0 ;
39197 PyObject * obj2 = 0 ;
39198 PyObject * obj3 = 0 ;
39199 PyObject * obj4 = 0 ;
39200 PyObject * obj5 = 0 ;
39201 char * kwnames[] = {
39202 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39203 };
39204
39205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39207 if (!SWIG_IsOK(res1)) {
39208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39209 }
39210 arg1 = reinterpret_cast< wxMenu * >(argp1);
39211 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39212 if (!SWIG_IsOK(ecode2)) {
39213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39214 }
39215 arg2 = static_cast< size_t >(val2);
39216 ecode3 = SWIG_AsVal_int(obj2, &val3);
39217 if (!SWIG_IsOK(ecode3)) {
39218 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39219 }
39220 arg3 = static_cast< int >(val3);
39221 {
39222 arg4 = wxString_in_helper(obj3);
39223 if (arg4 == NULL) SWIG_fail;
39224 temp4 = true;
39225 }
39226 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39227 if (!SWIG_IsOK(res5)) {
39228 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39229 }
39230 arg5 = reinterpret_cast< wxMenu * >(argp5);
39231 if (obj5) {
39232 {
39233 arg6 = wxString_in_helper(obj5);
39234 if (arg6 == NULL) SWIG_fail;
39235 temp6 = true;
39236 }
39237 }
39238 {
39239 PyThreadState* __tstate = wxPyBeginAllowThreads();
39240 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39241 wxPyEndAllowThreads(__tstate);
39242 if (PyErr_Occurred()) SWIG_fail;
39243 }
39244 {
39245 resultobj = wxPyMake_wxObject(result, (bool)0);
39246 }
39247 {
39248 if (temp4)
39249 delete arg4;
39250 }
39251 {
39252 if (temp6)
39253 delete arg6;
39254 }
39255 return resultobj;
39256 fail:
39257 {
39258 if (temp4)
39259 delete arg4;
39260 }
39261 {
39262 if (temp6)
39263 delete arg6;
39264 }
39265 return NULL;
39266 }
39267
39268
39269 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39270 PyObject *resultobj = 0;
39271 wxMenu *arg1 = (wxMenu *) 0 ;
39272 int arg2 ;
39273 wxString *arg3 = 0 ;
39274 wxString const &arg4_defvalue = wxPyEmptyString ;
39275 wxString *arg4 = (wxString *) &arg4_defvalue ;
39276 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39277 wxMenuItem *result = 0 ;
39278 void *argp1 = 0 ;
39279 int res1 = 0 ;
39280 int val2 ;
39281 int ecode2 = 0 ;
39282 bool temp3 = false ;
39283 bool temp4 = false ;
39284 int val5 ;
39285 int ecode5 = 0 ;
39286 PyObject * obj0 = 0 ;
39287 PyObject * obj1 = 0 ;
39288 PyObject * obj2 = 0 ;
39289 PyObject * obj3 = 0 ;
39290 PyObject * obj4 = 0 ;
39291 char * kwnames[] = {
39292 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39293 };
39294
39295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39297 if (!SWIG_IsOK(res1)) {
39298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39299 }
39300 arg1 = reinterpret_cast< wxMenu * >(argp1);
39301 ecode2 = SWIG_AsVal_int(obj1, &val2);
39302 if (!SWIG_IsOK(ecode2)) {
39303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39304 }
39305 arg2 = static_cast< int >(val2);
39306 {
39307 arg3 = wxString_in_helper(obj2);
39308 if (arg3 == NULL) SWIG_fail;
39309 temp3 = true;
39310 }
39311 if (obj3) {
39312 {
39313 arg4 = wxString_in_helper(obj3);
39314 if (arg4 == NULL) SWIG_fail;
39315 temp4 = true;
39316 }
39317 }
39318 if (obj4) {
39319 ecode5 = SWIG_AsVal_int(obj4, &val5);
39320 if (!SWIG_IsOK(ecode5)) {
39321 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39322 }
39323 arg5 = static_cast< wxItemKind >(val5);
39324 }
39325 {
39326 PyThreadState* __tstate = wxPyBeginAllowThreads();
39327 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39328 wxPyEndAllowThreads(__tstate);
39329 if (PyErr_Occurred()) SWIG_fail;
39330 }
39331 {
39332 resultobj = wxPyMake_wxObject(result, (bool)0);
39333 }
39334 {
39335 if (temp3)
39336 delete arg3;
39337 }
39338 {
39339 if (temp4)
39340 delete arg4;
39341 }
39342 return resultobj;
39343 fail:
39344 {
39345 if (temp3)
39346 delete arg3;
39347 }
39348 {
39349 if (temp4)
39350 delete arg4;
39351 }
39352 return NULL;
39353 }
39354
39355
39356 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39357 PyObject *resultobj = 0;
39358 wxMenu *arg1 = (wxMenu *) 0 ;
39359 wxMenuItem *result = 0 ;
39360 void *argp1 = 0 ;
39361 int res1 = 0 ;
39362 PyObject *swig_obj[1] ;
39363
39364 if (!args) SWIG_fail;
39365 swig_obj[0] = args;
39366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39367 if (!SWIG_IsOK(res1)) {
39368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39369 }
39370 arg1 = reinterpret_cast< wxMenu * >(argp1);
39371 {
39372 PyThreadState* __tstate = wxPyBeginAllowThreads();
39373 result = (wxMenuItem *)(arg1)->PrependSeparator();
39374 wxPyEndAllowThreads(__tstate);
39375 if (PyErr_Occurred()) SWIG_fail;
39376 }
39377 {
39378 resultobj = wxPyMake_wxObject(result, (bool)0);
39379 }
39380 return resultobj;
39381 fail:
39382 return NULL;
39383 }
39384
39385
39386 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39387 PyObject *resultobj = 0;
39388 wxMenu *arg1 = (wxMenu *) 0 ;
39389 int arg2 ;
39390 wxString *arg3 = 0 ;
39391 wxString const &arg4_defvalue = wxPyEmptyString ;
39392 wxString *arg4 = (wxString *) &arg4_defvalue ;
39393 wxMenuItem *result = 0 ;
39394 void *argp1 = 0 ;
39395 int res1 = 0 ;
39396 int val2 ;
39397 int ecode2 = 0 ;
39398 bool temp3 = false ;
39399 bool temp4 = false ;
39400 PyObject * obj0 = 0 ;
39401 PyObject * obj1 = 0 ;
39402 PyObject * obj2 = 0 ;
39403 PyObject * obj3 = 0 ;
39404 char * kwnames[] = {
39405 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39406 };
39407
39408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39410 if (!SWIG_IsOK(res1)) {
39411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39412 }
39413 arg1 = reinterpret_cast< wxMenu * >(argp1);
39414 ecode2 = SWIG_AsVal_int(obj1, &val2);
39415 if (!SWIG_IsOK(ecode2)) {
39416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39417 }
39418 arg2 = static_cast< int >(val2);
39419 {
39420 arg3 = wxString_in_helper(obj2);
39421 if (arg3 == NULL) SWIG_fail;
39422 temp3 = true;
39423 }
39424 if (obj3) {
39425 {
39426 arg4 = wxString_in_helper(obj3);
39427 if (arg4 == NULL) SWIG_fail;
39428 temp4 = true;
39429 }
39430 }
39431 {
39432 PyThreadState* __tstate = wxPyBeginAllowThreads();
39433 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39434 wxPyEndAllowThreads(__tstate);
39435 if (PyErr_Occurred()) SWIG_fail;
39436 }
39437 {
39438 resultobj = wxPyMake_wxObject(result, (bool)0);
39439 }
39440 {
39441 if (temp3)
39442 delete arg3;
39443 }
39444 {
39445 if (temp4)
39446 delete arg4;
39447 }
39448 return resultobj;
39449 fail:
39450 {
39451 if (temp3)
39452 delete arg3;
39453 }
39454 {
39455 if (temp4)
39456 delete arg4;
39457 }
39458 return NULL;
39459 }
39460
39461
39462 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39463 PyObject *resultobj = 0;
39464 wxMenu *arg1 = (wxMenu *) 0 ;
39465 int arg2 ;
39466 wxString *arg3 = 0 ;
39467 wxString const &arg4_defvalue = wxPyEmptyString ;
39468 wxString *arg4 = (wxString *) &arg4_defvalue ;
39469 wxMenuItem *result = 0 ;
39470 void *argp1 = 0 ;
39471 int res1 = 0 ;
39472 int val2 ;
39473 int ecode2 = 0 ;
39474 bool temp3 = false ;
39475 bool temp4 = false ;
39476 PyObject * obj0 = 0 ;
39477 PyObject * obj1 = 0 ;
39478 PyObject * obj2 = 0 ;
39479 PyObject * obj3 = 0 ;
39480 char * kwnames[] = {
39481 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39482 };
39483
39484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39486 if (!SWIG_IsOK(res1)) {
39487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39488 }
39489 arg1 = reinterpret_cast< wxMenu * >(argp1);
39490 ecode2 = SWIG_AsVal_int(obj1, &val2);
39491 if (!SWIG_IsOK(ecode2)) {
39492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39493 }
39494 arg2 = static_cast< int >(val2);
39495 {
39496 arg3 = wxString_in_helper(obj2);
39497 if (arg3 == NULL) SWIG_fail;
39498 temp3 = true;
39499 }
39500 if (obj3) {
39501 {
39502 arg4 = wxString_in_helper(obj3);
39503 if (arg4 == NULL) SWIG_fail;
39504 temp4 = true;
39505 }
39506 }
39507 {
39508 PyThreadState* __tstate = wxPyBeginAllowThreads();
39509 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39510 wxPyEndAllowThreads(__tstate);
39511 if (PyErr_Occurred()) SWIG_fail;
39512 }
39513 {
39514 resultobj = wxPyMake_wxObject(result, (bool)0);
39515 }
39516 {
39517 if (temp3)
39518 delete arg3;
39519 }
39520 {
39521 if (temp4)
39522 delete arg4;
39523 }
39524 return resultobj;
39525 fail:
39526 {
39527 if (temp3)
39528 delete arg3;
39529 }
39530 {
39531 if (temp4)
39532 delete arg4;
39533 }
39534 return NULL;
39535 }
39536
39537
39538 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39539 PyObject *resultobj = 0;
39540 wxMenu *arg1 = (wxMenu *) 0 ;
39541 int arg2 ;
39542 wxString *arg3 = 0 ;
39543 wxMenu *arg4 = (wxMenu *) 0 ;
39544 wxString const &arg5_defvalue = wxPyEmptyString ;
39545 wxString *arg5 = (wxString *) &arg5_defvalue ;
39546 wxMenuItem *result = 0 ;
39547 void *argp1 = 0 ;
39548 int res1 = 0 ;
39549 int val2 ;
39550 int ecode2 = 0 ;
39551 bool temp3 = false ;
39552 void *argp4 = 0 ;
39553 int res4 = 0 ;
39554 bool temp5 = false ;
39555 PyObject * obj0 = 0 ;
39556 PyObject * obj1 = 0 ;
39557 PyObject * obj2 = 0 ;
39558 PyObject * obj3 = 0 ;
39559 PyObject * obj4 = 0 ;
39560 char * kwnames[] = {
39561 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39562 };
39563
39564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39566 if (!SWIG_IsOK(res1)) {
39567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39568 }
39569 arg1 = reinterpret_cast< wxMenu * >(argp1);
39570 ecode2 = SWIG_AsVal_int(obj1, &val2);
39571 if (!SWIG_IsOK(ecode2)) {
39572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39573 }
39574 arg2 = static_cast< int >(val2);
39575 {
39576 arg3 = wxString_in_helper(obj2);
39577 if (arg3 == NULL) SWIG_fail;
39578 temp3 = true;
39579 }
39580 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39581 if (!SWIG_IsOK(res4)) {
39582 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39583 }
39584 arg4 = reinterpret_cast< wxMenu * >(argp4);
39585 if (obj4) {
39586 {
39587 arg5 = wxString_in_helper(obj4);
39588 if (arg5 == NULL) SWIG_fail;
39589 temp5 = true;
39590 }
39591 }
39592 {
39593 PyThreadState* __tstate = wxPyBeginAllowThreads();
39594 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39595 wxPyEndAllowThreads(__tstate);
39596 if (PyErr_Occurred()) SWIG_fail;
39597 }
39598 {
39599 resultobj = wxPyMake_wxObject(result, (bool)0);
39600 }
39601 {
39602 if (temp3)
39603 delete arg3;
39604 }
39605 {
39606 if (temp5)
39607 delete arg5;
39608 }
39609 return resultobj;
39610 fail:
39611 {
39612 if (temp3)
39613 delete arg3;
39614 }
39615 {
39616 if (temp5)
39617 delete arg5;
39618 }
39619 return NULL;
39620 }
39621
39622
39623 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39624 PyObject *resultobj = 0;
39625 wxMenu *arg1 = (wxMenu *) 0 ;
39626 int arg2 ;
39627 wxMenuItem *result = 0 ;
39628 void *argp1 = 0 ;
39629 int res1 = 0 ;
39630 int val2 ;
39631 int ecode2 = 0 ;
39632 PyObject * obj0 = 0 ;
39633 PyObject * obj1 = 0 ;
39634 char * kwnames[] = {
39635 (char *) "self",(char *) "id", NULL
39636 };
39637
39638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39640 if (!SWIG_IsOK(res1)) {
39641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39642 }
39643 arg1 = reinterpret_cast< wxMenu * >(argp1);
39644 ecode2 = SWIG_AsVal_int(obj1, &val2);
39645 if (!SWIG_IsOK(ecode2)) {
39646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39647 }
39648 arg2 = static_cast< int >(val2);
39649 {
39650 PyThreadState* __tstate = wxPyBeginAllowThreads();
39651 result = (wxMenuItem *)(arg1)->Remove(arg2);
39652 wxPyEndAllowThreads(__tstate);
39653 if (PyErr_Occurred()) SWIG_fail;
39654 }
39655 {
39656 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39657 }
39658 return resultobj;
39659 fail:
39660 return NULL;
39661 }
39662
39663
39664 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39665 PyObject *resultobj = 0;
39666 wxMenu *arg1 = (wxMenu *) 0 ;
39667 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39668 wxMenuItem *result = 0 ;
39669 void *argp1 = 0 ;
39670 int res1 = 0 ;
39671 void *argp2 = 0 ;
39672 int res2 = 0 ;
39673 PyObject * obj0 = 0 ;
39674 PyObject * obj1 = 0 ;
39675 char * kwnames[] = {
39676 (char *) "self",(char *) "item", NULL
39677 };
39678
39679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39681 if (!SWIG_IsOK(res1)) {
39682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39683 }
39684 arg1 = reinterpret_cast< wxMenu * >(argp1);
39685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39686 if (!SWIG_IsOK(res2)) {
39687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39688 }
39689 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39690 {
39691 PyThreadState* __tstate = wxPyBeginAllowThreads();
39692 result = (wxMenuItem *)(arg1)->Remove(arg2);
39693 wxPyEndAllowThreads(__tstate);
39694 if (PyErr_Occurred()) SWIG_fail;
39695 }
39696 {
39697 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39698 }
39699 return resultobj;
39700 fail:
39701 return NULL;
39702 }
39703
39704
39705 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39706 PyObject *resultobj = 0;
39707 wxMenu *arg1 = (wxMenu *) 0 ;
39708 int arg2 ;
39709 bool result;
39710 void *argp1 = 0 ;
39711 int res1 = 0 ;
39712 int val2 ;
39713 int ecode2 = 0 ;
39714 PyObject * obj0 = 0 ;
39715 PyObject * obj1 = 0 ;
39716 char * kwnames[] = {
39717 (char *) "self",(char *) "id", NULL
39718 };
39719
39720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39722 if (!SWIG_IsOK(res1)) {
39723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39724 }
39725 arg1 = reinterpret_cast< wxMenu * >(argp1);
39726 ecode2 = SWIG_AsVal_int(obj1, &val2);
39727 if (!SWIG_IsOK(ecode2)) {
39728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39729 }
39730 arg2 = static_cast< int >(val2);
39731 {
39732 PyThreadState* __tstate = wxPyBeginAllowThreads();
39733 result = (bool)(arg1)->Delete(arg2);
39734 wxPyEndAllowThreads(__tstate);
39735 if (PyErr_Occurred()) SWIG_fail;
39736 }
39737 {
39738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39739 }
39740 return resultobj;
39741 fail:
39742 return NULL;
39743 }
39744
39745
39746 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39747 PyObject *resultobj = 0;
39748 wxMenu *arg1 = (wxMenu *) 0 ;
39749 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39750 bool result;
39751 void *argp1 = 0 ;
39752 int res1 = 0 ;
39753 void *argp2 = 0 ;
39754 int res2 = 0 ;
39755 PyObject * obj0 = 0 ;
39756 PyObject * obj1 = 0 ;
39757 char * kwnames[] = {
39758 (char *) "self",(char *) "item", NULL
39759 };
39760
39761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39763 if (!SWIG_IsOK(res1)) {
39764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39765 }
39766 arg1 = reinterpret_cast< wxMenu * >(argp1);
39767 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39768 if (!SWIG_IsOK(res2)) {
39769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39770 }
39771 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39772 {
39773 PyThreadState* __tstate = wxPyBeginAllowThreads();
39774 result = (bool)(arg1)->Delete(arg2);
39775 wxPyEndAllowThreads(__tstate);
39776 if (PyErr_Occurred()) SWIG_fail;
39777 }
39778 {
39779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39780 }
39781 return resultobj;
39782 fail:
39783 return NULL;
39784 }
39785
39786
39787 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39788 PyObject *resultobj = 0;
39789 wxMenu *arg1 = (wxMenu *) 0 ;
39790 void *argp1 = 0 ;
39791 int res1 = 0 ;
39792 PyObject *swig_obj[1] ;
39793
39794 if (!args) SWIG_fail;
39795 swig_obj[0] = args;
39796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39797 if (!SWIG_IsOK(res1)) {
39798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39799 }
39800 arg1 = reinterpret_cast< wxMenu * >(argp1);
39801 {
39802 PyThreadState* __tstate = wxPyBeginAllowThreads();
39803 wxMenu_Destroy(arg1);
39804 wxPyEndAllowThreads(__tstate);
39805 if (PyErr_Occurred()) SWIG_fail;
39806 }
39807 resultobj = SWIG_Py_Void();
39808 return resultobj;
39809 fail:
39810 return NULL;
39811 }
39812
39813
39814 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39815 PyObject *resultobj = 0;
39816 wxMenu *arg1 = (wxMenu *) 0 ;
39817 int arg2 ;
39818 bool result;
39819 void *argp1 = 0 ;
39820 int res1 = 0 ;
39821 int val2 ;
39822 int ecode2 = 0 ;
39823 PyObject * obj0 = 0 ;
39824 PyObject * obj1 = 0 ;
39825 char * kwnames[] = {
39826 (char *) "self",(char *) "id", NULL
39827 };
39828
39829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39831 if (!SWIG_IsOK(res1)) {
39832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39833 }
39834 arg1 = reinterpret_cast< wxMenu * >(argp1);
39835 ecode2 = SWIG_AsVal_int(obj1, &val2);
39836 if (!SWIG_IsOK(ecode2)) {
39837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39838 }
39839 arg2 = static_cast< int >(val2);
39840 {
39841 PyThreadState* __tstate = wxPyBeginAllowThreads();
39842 result = (bool)(arg1)->Destroy(arg2);
39843 wxPyEndAllowThreads(__tstate);
39844 if (PyErr_Occurred()) SWIG_fail;
39845 }
39846 {
39847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39848 }
39849 return resultobj;
39850 fail:
39851 return NULL;
39852 }
39853
39854
39855 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39856 PyObject *resultobj = 0;
39857 wxMenu *arg1 = (wxMenu *) 0 ;
39858 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39859 bool result;
39860 void *argp1 = 0 ;
39861 int res1 = 0 ;
39862 void *argp2 = 0 ;
39863 int res2 = 0 ;
39864 PyObject * obj0 = 0 ;
39865 PyObject * obj1 = 0 ;
39866 char * kwnames[] = {
39867 (char *) "self",(char *) "item", NULL
39868 };
39869
39870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39872 if (!SWIG_IsOK(res1)) {
39873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39874 }
39875 arg1 = reinterpret_cast< wxMenu * >(argp1);
39876 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39877 if (!SWIG_IsOK(res2)) {
39878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39879 }
39880 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39881 {
39882 PyThreadState* __tstate = wxPyBeginAllowThreads();
39883 result = (bool)(arg1)->Destroy(arg2);
39884 wxPyEndAllowThreads(__tstate);
39885 if (PyErr_Occurred()) SWIG_fail;
39886 }
39887 {
39888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39889 }
39890 return resultobj;
39891 fail:
39892 return NULL;
39893 }
39894
39895
39896 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39897 PyObject *resultobj = 0;
39898 wxMenu *arg1 = (wxMenu *) 0 ;
39899 size_t result;
39900 void *argp1 = 0 ;
39901 int res1 = 0 ;
39902 PyObject *swig_obj[1] ;
39903
39904 if (!args) SWIG_fail;
39905 swig_obj[0] = args;
39906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39907 if (!SWIG_IsOK(res1)) {
39908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39909 }
39910 arg1 = reinterpret_cast< wxMenu * >(argp1);
39911 {
39912 PyThreadState* __tstate = wxPyBeginAllowThreads();
39913 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39914 wxPyEndAllowThreads(__tstate);
39915 if (PyErr_Occurred()) SWIG_fail;
39916 }
39917 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39918 return resultobj;
39919 fail:
39920 return NULL;
39921 }
39922
39923
39924 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39925 PyObject *resultobj = 0;
39926 wxMenu *arg1 = (wxMenu *) 0 ;
39927 PyObject *result = 0 ;
39928 void *argp1 = 0 ;
39929 int res1 = 0 ;
39930 PyObject *swig_obj[1] ;
39931
39932 if (!args) SWIG_fail;
39933 swig_obj[0] = args;
39934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39935 if (!SWIG_IsOK(res1)) {
39936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39937 }
39938 arg1 = reinterpret_cast< wxMenu * >(argp1);
39939 {
39940 PyThreadState* __tstate = wxPyBeginAllowThreads();
39941 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39942 wxPyEndAllowThreads(__tstate);
39943 if (PyErr_Occurred()) SWIG_fail;
39944 }
39945 resultobj = result;
39946 return resultobj;
39947 fail:
39948 return NULL;
39949 }
39950
39951
39952 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39953 PyObject *resultobj = 0;
39954 wxMenu *arg1 = (wxMenu *) 0 ;
39955 wxString *arg2 = 0 ;
39956 int result;
39957 void *argp1 = 0 ;
39958 int res1 = 0 ;
39959 bool temp2 = false ;
39960 PyObject * obj0 = 0 ;
39961 PyObject * obj1 = 0 ;
39962 char * kwnames[] = {
39963 (char *) "self",(char *) "item", NULL
39964 };
39965
39966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39968 if (!SWIG_IsOK(res1)) {
39969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39970 }
39971 arg1 = reinterpret_cast< wxMenu * >(argp1);
39972 {
39973 arg2 = wxString_in_helper(obj1);
39974 if (arg2 == NULL) SWIG_fail;
39975 temp2 = true;
39976 }
39977 {
39978 PyThreadState* __tstate = wxPyBeginAllowThreads();
39979 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39980 wxPyEndAllowThreads(__tstate);
39981 if (PyErr_Occurred()) SWIG_fail;
39982 }
39983 resultobj = SWIG_From_int(static_cast< int >(result));
39984 {
39985 if (temp2)
39986 delete arg2;
39987 }
39988 return resultobj;
39989 fail:
39990 {
39991 if (temp2)
39992 delete arg2;
39993 }
39994 return NULL;
39995 }
39996
39997
39998 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39999 PyObject *resultobj = 0;
40000 wxMenu *arg1 = (wxMenu *) 0 ;
40001 int arg2 ;
40002 wxMenuItem *result = 0 ;
40003 void *argp1 = 0 ;
40004 int res1 = 0 ;
40005 int val2 ;
40006 int ecode2 = 0 ;
40007 PyObject * obj0 = 0 ;
40008 PyObject * obj1 = 0 ;
40009 char * kwnames[] = {
40010 (char *) "self",(char *) "id", NULL
40011 };
40012
40013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40015 if (!SWIG_IsOK(res1)) {
40016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40017 }
40018 arg1 = reinterpret_cast< wxMenu * >(argp1);
40019 ecode2 = SWIG_AsVal_int(obj1, &val2);
40020 if (!SWIG_IsOK(ecode2)) {
40021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40022 }
40023 arg2 = static_cast< int >(val2);
40024 {
40025 PyThreadState* __tstate = wxPyBeginAllowThreads();
40026 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40027 wxPyEndAllowThreads(__tstate);
40028 if (PyErr_Occurred()) SWIG_fail;
40029 }
40030 {
40031 resultobj = wxPyMake_wxObject(result, (bool)0);
40032 }
40033 return resultobj;
40034 fail:
40035 return NULL;
40036 }
40037
40038
40039 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40040 PyObject *resultobj = 0;
40041 wxMenu *arg1 = (wxMenu *) 0 ;
40042 size_t arg2 ;
40043 wxMenuItem *result = 0 ;
40044 void *argp1 = 0 ;
40045 int res1 = 0 ;
40046 size_t val2 ;
40047 int ecode2 = 0 ;
40048 PyObject * obj0 = 0 ;
40049 PyObject * obj1 = 0 ;
40050 char * kwnames[] = {
40051 (char *) "self",(char *) "position", NULL
40052 };
40053
40054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40056 if (!SWIG_IsOK(res1)) {
40057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40058 }
40059 arg1 = reinterpret_cast< wxMenu * >(argp1);
40060 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40061 if (!SWIG_IsOK(ecode2)) {
40062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40063 }
40064 arg2 = static_cast< size_t >(val2);
40065 {
40066 PyThreadState* __tstate = wxPyBeginAllowThreads();
40067 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40068 wxPyEndAllowThreads(__tstate);
40069 if (PyErr_Occurred()) SWIG_fail;
40070 }
40071 {
40072 resultobj = wxPyMake_wxObject(result, (bool)0);
40073 }
40074 return resultobj;
40075 fail:
40076 return NULL;
40077 }
40078
40079
40080 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40081 PyObject *resultobj = 0;
40082 wxMenu *arg1 = (wxMenu *) 0 ;
40083 int arg2 ;
40084 bool arg3 ;
40085 void *argp1 = 0 ;
40086 int res1 = 0 ;
40087 int val2 ;
40088 int ecode2 = 0 ;
40089 bool val3 ;
40090 int ecode3 = 0 ;
40091 PyObject * obj0 = 0 ;
40092 PyObject * obj1 = 0 ;
40093 PyObject * obj2 = 0 ;
40094 char * kwnames[] = {
40095 (char *) "self",(char *) "id",(char *) "enable", NULL
40096 };
40097
40098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40100 if (!SWIG_IsOK(res1)) {
40101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40102 }
40103 arg1 = reinterpret_cast< wxMenu * >(argp1);
40104 ecode2 = SWIG_AsVal_int(obj1, &val2);
40105 if (!SWIG_IsOK(ecode2)) {
40106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40107 }
40108 arg2 = static_cast< int >(val2);
40109 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40110 if (!SWIG_IsOK(ecode3)) {
40111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40112 }
40113 arg3 = static_cast< bool >(val3);
40114 {
40115 PyThreadState* __tstate = wxPyBeginAllowThreads();
40116 (arg1)->Enable(arg2,arg3);
40117 wxPyEndAllowThreads(__tstate);
40118 if (PyErr_Occurred()) SWIG_fail;
40119 }
40120 resultobj = SWIG_Py_Void();
40121 return resultobj;
40122 fail:
40123 return NULL;
40124 }
40125
40126
40127 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40128 PyObject *resultobj = 0;
40129 wxMenu *arg1 = (wxMenu *) 0 ;
40130 int arg2 ;
40131 bool result;
40132 void *argp1 = 0 ;
40133 int res1 = 0 ;
40134 int val2 ;
40135 int ecode2 = 0 ;
40136 PyObject * obj0 = 0 ;
40137 PyObject * obj1 = 0 ;
40138 char * kwnames[] = {
40139 (char *) "self",(char *) "id", NULL
40140 };
40141
40142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40144 if (!SWIG_IsOK(res1)) {
40145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40146 }
40147 arg1 = reinterpret_cast< wxMenu * >(argp1);
40148 ecode2 = SWIG_AsVal_int(obj1, &val2);
40149 if (!SWIG_IsOK(ecode2)) {
40150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40151 }
40152 arg2 = static_cast< int >(val2);
40153 {
40154 PyThreadState* __tstate = wxPyBeginAllowThreads();
40155 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40156 wxPyEndAllowThreads(__tstate);
40157 if (PyErr_Occurred()) SWIG_fail;
40158 }
40159 {
40160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40161 }
40162 return resultobj;
40163 fail:
40164 return NULL;
40165 }
40166
40167
40168 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40169 PyObject *resultobj = 0;
40170 wxMenu *arg1 = (wxMenu *) 0 ;
40171 int arg2 ;
40172 bool arg3 ;
40173 void *argp1 = 0 ;
40174 int res1 = 0 ;
40175 int val2 ;
40176 int ecode2 = 0 ;
40177 bool val3 ;
40178 int ecode3 = 0 ;
40179 PyObject * obj0 = 0 ;
40180 PyObject * obj1 = 0 ;
40181 PyObject * obj2 = 0 ;
40182 char * kwnames[] = {
40183 (char *) "self",(char *) "id",(char *) "check", NULL
40184 };
40185
40186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40188 if (!SWIG_IsOK(res1)) {
40189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40190 }
40191 arg1 = reinterpret_cast< wxMenu * >(argp1);
40192 ecode2 = SWIG_AsVal_int(obj1, &val2);
40193 if (!SWIG_IsOK(ecode2)) {
40194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40195 }
40196 arg2 = static_cast< int >(val2);
40197 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40198 if (!SWIG_IsOK(ecode3)) {
40199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40200 }
40201 arg3 = static_cast< bool >(val3);
40202 {
40203 PyThreadState* __tstate = wxPyBeginAllowThreads();
40204 (arg1)->Check(arg2,arg3);
40205 wxPyEndAllowThreads(__tstate);
40206 if (PyErr_Occurred()) SWIG_fail;
40207 }
40208 resultobj = SWIG_Py_Void();
40209 return resultobj;
40210 fail:
40211 return NULL;
40212 }
40213
40214
40215 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40216 PyObject *resultobj = 0;
40217 wxMenu *arg1 = (wxMenu *) 0 ;
40218 int arg2 ;
40219 bool result;
40220 void *argp1 = 0 ;
40221 int res1 = 0 ;
40222 int val2 ;
40223 int ecode2 = 0 ;
40224 PyObject * obj0 = 0 ;
40225 PyObject * obj1 = 0 ;
40226 char * kwnames[] = {
40227 (char *) "self",(char *) "id", NULL
40228 };
40229
40230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40232 if (!SWIG_IsOK(res1)) {
40233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40234 }
40235 arg1 = reinterpret_cast< wxMenu * >(argp1);
40236 ecode2 = SWIG_AsVal_int(obj1, &val2);
40237 if (!SWIG_IsOK(ecode2)) {
40238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40239 }
40240 arg2 = static_cast< int >(val2);
40241 {
40242 PyThreadState* __tstate = wxPyBeginAllowThreads();
40243 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40244 wxPyEndAllowThreads(__tstate);
40245 if (PyErr_Occurred()) SWIG_fail;
40246 }
40247 {
40248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40249 }
40250 return resultobj;
40251 fail:
40252 return NULL;
40253 }
40254
40255
40256 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40257 PyObject *resultobj = 0;
40258 wxMenu *arg1 = (wxMenu *) 0 ;
40259 int arg2 ;
40260 wxString *arg3 = 0 ;
40261 void *argp1 = 0 ;
40262 int res1 = 0 ;
40263 int val2 ;
40264 int ecode2 = 0 ;
40265 bool temp3 = false ;
40266 PyObject * obj0 = 0 ;
40267 PyObject * obj1 = 0 ;
40268 PyObject * obj2 = 0 ;
40269 char * kwnames[] = {
40270 (char *) "self",(char *) "id",(char *) "label", NULL
40271 };
40272
40273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40275 if (!SWIG_IsOK(res1)) {
40276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40277 }
40278 arg1 = reinterpret_cast< wxMenu * >(argp1);
40279 ecode2 = SWIG_AsVal_int(obj1, &val2);
40280 if (!SWIG_IsOK(ecode2)) {
40281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40282 }
40283 arg2 = static_cast< int >(val2);
40284 {
40285 arg3 = wxString_in_helper(obj2);
40286 if (arg3 == NULL) SWIG_fail;
40287 temp3 = true;
40288 }
40289 {
40290 PyThreadState* __tstate = wxPyBeginAllowThreads();
40291 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40292 wxPyEndAllowThreads(__tstate);
40293 if (PyErr_Occurred()) SWIG_fail;
40294 }
40295 resultobj = SWIG_Py_Void();
40296 {
40297 if (temp3)
40298 delete arg3;
40299 }
40300 return resultobj;
40301 fail:
40302 {
40303 if (temp3)
40304 delete arg3;
40305 }
40306 return NULL;
40307 }
40308
40309
40310 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40311 PyObject *resultobj = 0;
40312 wxMenu *arg1 = (wxMenu *) 0 ;
40313 int arg2 ;
40314 wxString result;
40315 void *argp1 = 0 ;
40316 int res1 = 0 ;
40317 int val2 ;
40318 int ecode2 = 0 ;
40319 PyObject * obj0 = 0 ;
40320 PyObject * obj1 = 0 ;
40321 char * kwnames[] = {
40322 (char *) "self",(char *) "id", NULL
40323 };
40324
40325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40327 if (!SWIG_IsOK(res1)) {
40328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40329 }
40330 arg1 = reinterpret_cast< wxMenu * >(argp1);
40331 ecode2 = SWIG_AsVal_int(obj1, &val2);
40332 if (!SWIG_IsOK(ecode2)) {
40333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40334 }
40335 arg2 = static_cast< int >(val2);
40336 {
40337 PyThreadState* __tstate = wxPyBeginAllowThreads();
40338 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40339 wxPyEndAllowThreads(__tstate);
40340 if (PyErr_Occurred()) SWIG_fail;
40341 }
40342 {
40343 #if wxUSE_UNICODE
40344 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40345 #else
40346 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40347 #endif
40348 }
40349 return resultobj;
40350 fail:
40351 return NULL;
40352 }
40353
40354
40355 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40356 PyObject *resultobj = 0;
40357 wxMenu *arg1 = (wxMenu *) 0 ;
40358 int arg2 ;
40359 wxString *arg3 = 0 ;
40360 void *argp1 = 0 ;
40361 int res1 = 0 ;
40362 int val2 ;
40363 int ecode2 = 0 ;
40364 bool temp3 = false ;
40365 PyObject * obj0 = 0 ;
40366 PyObject * obj1 = 0 ;
40367 PyObject * obj2 = 0 ;
40368 char * kwnames[] = {
40369 (char *) "self",(char *) "id",(char *) "helpString", NULL
40370 };
40371
40372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40374 if (!SWIG_IsOK(res1)) {
40375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40376 }
40377 arg1 = reinterpret_cast< wxMenu * >(argp1);
40378 ecode2 = SWIG_AsVal_int(obj1, &val2);
40379 if (!SWIG_IsOK(ecode2)) {
40380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40381 }
40382 arg2 = static_cast< int >(val2);
40383 {
40384 arg3 = wxString_in_helper(obj2);
40385 if (arg3 == NULL) SWIG_fail;
40386 temp3 = true;
40387 }
40388 {
40389 PyThreadState* __tstate = wxPyBeginAllowThreads();
40390 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40391 wxPyEndAllowThreads(__tstate);
40392 if (PyErr_Occurred()) SWIG_fail;
40393 }
40394 resultobj = SWIG_Py_Void();
40395 {
40396 if (temp3)
40397 delete arg3;
40398 }
40399 return resultobj;
40400 fail:
40401 {
40402 if (temp3)
40403 delete arg3;
40404 }
40405 return NULL;
40406 }
40407
40408
40409 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40410 PyObject *resultobj = 0;
40411 wxMenu *arg1 = (wxMenu *) 0 ;
40412 int arg2 ;
40413 wxString result;
40414 void *argp1 = 0 ;
40415 int res1 = 0 ;
40416 int val2 ;
40417 int ecode2 = 0 ;
40418 PyObject * obj0 = 0 ;
40419 PyObject * obj1 = 0 ;
40420 char * kwnames[] = {
40421 (char *) "self",(char *) "id", NULL
40422 };
40423
40424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40426 if (!SWIG_IsOK(res1)) {
40427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40428 }
40429 arg1 = reinterpret_cast< wxMenu * >(argp1);
40430 ecode2 = SWIG_AsVal_int(obj1, &val2);
40431 if (!SWIG_IsOK(ecode2)) {
40432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40433 }
40434 arg2 = static_cast< int >(val2);
40435 {
40436 PyThreadState* __tstate = wxPyBeginAllowThreads();
40437 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40438 wxPyEndAllowThreads(__tstate);
40439 if (PyErr_Occurred()) SWIG_fail;
40440 }
40441 {
40442 #if wxUSE_UNICODE
40443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40444 #else
40445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40446 #endif
40447 }
40448 return resultobj;
40449 fail:
40450 return NULL;
40451 }
40452
40453
40454 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40455 PyObject *resultobj = 0;
40456 wxMenu *arg1 = (wxMenu *) 0 ;
40457 wxString *arg2 = 0 ;
40458 void *argp1 = 0 ;
40459 int res1 = 0 ;
40460 bool temp2 = false ;
40461 PyObject * obj0 = 0 ;
40462 PyObject * obj1 = 0 ;
40463 char * kwnames[] = {
40464 (char *) "self",(char *) "title", NULL
40465 };
40466
40467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40469 if (!SWIG_IsOK(res1)) {
40470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40471 }
40472 arg1 = reinterpret_cast< wxMenu * >(argp1);
40473 {
40474 arg2 = wxString_in_helper(obj1);
40475 if (arg2 == NULL) SWIG_fail;
40476 temp2 = true;
40477 }
40478 {
40479 PyThreadState* __tstate = wxPyBeginAllowThreads();
40480 (arg1)->SetTitle((wxString const &)*arg2);
40481 wxPyEndAllowThreads(__tstate);
40482 if (PyErr_Occurred()) SWIG_fail;
40483 }
40484 resultobj = SWIG_Py_Void();
40485 {
40486 if (temp2)
40487 delete arg2;
40488 }
40489 return resultobj;
40490 fail:
40491 {
40492 if (temp2)
40493 delete arg2;
40494 }
40495 return NULL;
40496 }
40497
40498
40499 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40500 PyObject *resultobj = 0;
40501 wxMenu *arg1 = (wxMenu *) 0 ;
40502 wxString result;
40503 void *argp1 = 0 ;
40504 int res1 = 0 ;
40505 PyObject *swig_obj[1] ;
40506
40507 if (!args) SWIG_fail;
40508 swig_obj[0] = args;
40509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40510 if (!SWIG_IsOK(res1)) {
40511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40512 }
40513 arg1 = reinterpret_cast< wxMenu * >(argp1);
40514 {
40515 PyThreadState* __tstate = wxPyBeginAllowThreads();
40516 result = ((wxMenu const *)arg1)->GetTitle();
40517 wxPyEndAllowThreads(__tstate);
40518 if (PyErr_Occurred()) SWIG_fail;
40519 }
40520 {
40521 #if wxUSE_UNICODE
40522 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40523 #else
40524 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40525 #endif
40526 }
40527 return resultobj;
40528 fail:
40529 return NULL;
40530 }
40531
40532
40533 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40534 PyObject *resultobj = 0;
40535 wxMenu *arg1 = (wxMenu *) 0 ;
40536 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40537 void *argp1 = 0 ;
40538 int res1 = 0 ;
40539 void *argp2 = 0 ;
40540 int res2 = 0 ;
40541 PyObject * obj0 = 0 ;
40542 PyObject * obj1 = 0 ;
40543 char * kwnames[] = {
40544 (char *) "self",(char *) "handler", NULL
40545 };
40546
40547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40549 if (!SWIG_IsOK(res1)) {
40550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40551 }
40552 arg1 = reinterpret_cast< wxMenu * >(argp1);
40553 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40554 if (!SWIG_IsOK(res2)) {
40555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40556 }
40557 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40558 {
40559 PyThreadState* __tstate = wxPyBeginAllowThreads();
40560 (arg1)->SetEventHandler(arg2);
40561 wxPyEndAllowThreads(__tstate);
40562 if (PyErr_Occurred()) SWIG_fail;
40563 }
40564 resultobj = SWIG_Py_Void();
40565 return resultobj;
40566 fail:
40567 return NULL;
40568 }
40569
40570
40571 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40572 PyObject *resultobj = 0;
40573 wxMenu *arg1 = (wxMenu *) 0 ;
40574 wxEvtHandler *result = 0 ;
40575 void *argp1 = 0 ;
40576 int res1 = 0 ;
40577 PyObject *swig_obj[1] ;
40578
40579 if (!args) SWIG_fail;
40580 swig_obj[0] = args;
40581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40582 if (!SWIG_IsOK(res1)) {
40583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40584 }
40585 arg1 = reinterpret_cast< wxMenu * >(argp1);
40586 {
40587 PyThreadState* __tstate = wxPyBeginAllowThreads();
40588 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40589 wxPyEndAllowThreads(__tstate);
40590 if (PyErr_Occurred()) SWIG_fail;
40591 }
40592 {
40593 resultobj = wxPyMake_wxObject(result, 0);
40594 }
40595 return resultobj;
40596 fail:
40597 return NULL;
40598 }
40599
40600
40601 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40602 PyObject *resultobj = 0;
40603 wxMenu *arg1 = (wxMenu *) 0 ;
40604 wxWindow *arg2 = (wxWindow *) 0 ;
40605 void *argp1 = 0 ;
40606 int res1 = 0 ;
40607 void *argp2 = 0 ;
40608 int res2 = 0 ;
40609 PyObject * obj0 = 0 ;
40610 PyObject * obj1 = 0 ;
40611 char * kwnames[] = {
40612 (char *) "self",(char *) "win", NULL
40613 };
40614
40615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40617 if (!SWIG_IsOK(res1)) {
40618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40619 }
40620 arg1 = reinterpret_cast< wxMenu * >(argp1);
40621 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40622 if (!SWIG_IsOK(res2)) {
40623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40624 }
40625 arg2 = reinterpret_cast< wxWindow * >(argp2);
40626 {
40627 PyThreadState* __tstate = wxPyBeginAllowThreads();
40628 (arg1)->SetInvokingWindow(arg2);
40629 wxPyEndAllowThreads(__tstate);
40630 if (PyErr_Occurred()) SWIG_fail;
40631 }
40632 resultobj = SWIG_Py_Void();
40633 return resultobj;
40634 fail:
40635 return NULL;
40636 }
40637
40638
40639 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40640 PyObject *resultobj = 0;
40641 wxMenu *arg1 = (wxMenu *) 0 ;
40642 wxWindow *result = 0 ;
40643 void *argp1 = 0 ;
40644 int res1 = 0 ;
40645 PyObject *swig_obj[1] ;
40646
40647 if (!args) SWIG_fail;
40648 swig_obj[0] = args;
40649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40650 if (!SWIG_IsOK(res1)) {
40651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40652 }
40653 arg1 = reinterpret_cast< wxMenu * >(argp1);
40654 {
40655 PyThreadState* __tstate = wxPyBeginAllowThreads();
40656 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40657 wxPyEndAllowThreads(__tstate);
40658 if (PyErr_Occurred()) SWIG_fail;
40659 }
40660 {
40661 resultobj = wxPyMake_wxObject(result, 0);
40662 }
40663 return resultobj;
40664 fail:
40665 return NULL;
40666 }
40667
40668
40669 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40670 PyObject *resultobj = 0;
40671 wxMenu *arg1 = (wxMenu *) 0 ;
40672 long result;
40673 void *argp1 = 0 ;
40674 int res1 = 0 ;
40675 PyObject *swig_obj[1] ;
40676
40677 if (!args) SWIG_fail;
40678 swig_obj[0] = args;
40679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40680 if (!SWIG_IsOK(res1)) {
40681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40682 }
40683 arg1 = reinterpret_cast< wxMenu * >(argp1);
40684 {
40685 PyThreadState* __tstate = wxPyBeginAllowThreads();
40686 result = (long)((wxMenu const *)arg1)->GetStyle();
40687 wxPyEndAllowThreads(__tstate);
40688 if (PyErr_Occurred()) SWIG_fail;
40689 }
40690 resultobj = SWIG_From_long(static_cast< long >(result));
40691 return resultobj;
40692 fail:
40693 return NULL;
40694 }
40695
40696
40697 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40698 PyObject *resultobj = 0;
40699 wxMenu *arg1 = (wxMenu *) 0 ;
40700 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40701 void *argp1 = 0 ;
40702 int res1 = 0 ;
40703 void *argp2 = 0 ;
40704 int res2 = 0 ;
40705 PyObject * obj0 = 0 ;
40706 PyObject * obj1 = 0 ;
40707 char * kwnames[] = {
40708 (char *) "self",(char *) "source", NULL
40709 };
40710
40711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40713 if (!SWIG_IsOK(res1)) {
40714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40715 }
40716 arg1 = reinterpret_cast< wxMenu * >(argp1);
40717 if (obj1) {
40718 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40719 if (!SWIG_IsOK(res2)) {
40720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40721 }
40722 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40723 }
40724 {
40725 PyThreadState* __tstate = wxPyBeginAllowThreads();
40726 (arg1)->UpdateUI(arg2);
40727 wxPyEndAllowThreads(__tstate);
40728 if (PyErr_Occurred()) SWIG_fail;
40729 }
40730 resultobj = SWIG_Py_Void();
40731 return resultobj;
40732 fail:
40733 return NULL;
40734 }
40735
40736
40737 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40738 PyObject *resultobj = 0;
40739 wxMenu *arg1 = (wxMenu *) 0 ;
40740 wxMenuBar *result = 0 ;
40741 void *argp1 = 0 ;
40742 int res1 = 0 ;
40743 PyObject *swig_obj[1] ;
40744
40745 if (!args) SWIG_fail;
40746 swig_obj[0] = args;
40747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40748 if (!SWIG_IsOK(res1)) {
40749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40750 }
40751 arg1 = reinterpret_cast< wxMenu * >(argp1);
40752 {
40753 PyThreadState* __tstate = wxPyBeginAllowThreads();
40754 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40755 wxPyEndAllowThreads(__tstate);
40756 if (PyErr_Occurred()) SWIG_fail;
40757 }
40758 {
40759 resultobj = wxPyMake_wxObject(result, (bool)0);
40760 }
40761 return resultobj;
40762 fail:
40763 return NULL;
40764 }
40765
40766
40767 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40768 PyObject *resultobj = 0;
40769 wxMenu *arg1 = (wxMenu *) 0 ;
40770 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40771 void *argp1 = 0 ;
40772 int res1 = 0 ;
40773 void *argp2 = 0 ;
40774 int res2 = 0 ;
40775 PyObject * obj0 = 0 ;
40776 PyObject * obj1 = 0 ;
40777 char * kwnames[] = {
40778 (char *) "self",(char *) "menubar", NULL
40779 };
40780
40781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40783 if (!SWIG_IsOK(res1)) {
40784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40785 }
40786 arg1 = reinterpret_cast< wxMenu * >(argp1);
40787 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40788 if (!SWIG_IsOK(res2)) {
40789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40790 }
40791 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40792 {
40793 PyThreadState* __tstate = wxPyBeginAllowThreads();
40794 (arg1)->Attach(arg2);
40795 wxPyEndAllowThreads(__tstate);
40796 if (PyErr_Occurred()) SWIG_fail;
40797 }
40798 resultobj = SWIG_Py_Void();
40799 return resultobj;
40800 fail:
40801 return NULL;
40802 }
40803
40804
40805 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40806 PyObject *resultobj = 0;
40807 wxMenu *arg1 = (wxMenu *) 0 ;
40808 void *argp1 = 0 ;
40809 int res1 = 0 ;
40810 PyObject *swig_obj[1] ;
40811
40812 if (!args) SWIG_fail;
40813 swig_obj[0] = args;
40814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40815 if (!SWIG_IsOK(res1)) {
40816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40817 }
40818 arg1 = reinterpret_cast< wxMenu * >(argp1);
40819 {
40820 PyThreadState* __tstate = wxPyBeginAllowThreads();
40821 (arg1)->Detach();
40822 wxPyEndAllowThreads(__tstate);
40823 if (PyErr_Occurred()) SWIG_fail;
40824 }
40825 resultobj = SWIG_Py_Void();
40826 return resultobj;
40827 fail:
40828 return NULL;
40829 }
40830
40831
40832 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40833 PyObject *resultobj = 0;
40834 wxMenu *arg1 = (wxMenu *) 0 ;
40835 bool result;
40836 void *argp1 = 0 ;
40837 int res1 = 0 ;
40838 PyObject *swig_obj[1] ;
40839
40840 if (!args) SWIG_fail;
40841 swig_obj[0] = args;
40842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40843 if (!SWIG_IsOK(res1)) {
40844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40845 }
40846 arg1 = reinterpret_cast< wxMenu * >(argp1);
40847 {
40848 PyThreadState* __tstate = wxPyBeginAllowThreads();
40849 result = (bool)((wxMenu const *)arg1)->IsAttached();
40850 wxPyEndAllowThreads(__tstate);
40851 if (PyErr_Occurred()) SWIG_fail;
40852 }
40853 {
40854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40855 }
40856 return resultobj;
40857 fail:
40858 return NULL;
40859 }
40860
40861
40862 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40863 PyObject *resultobj = 0;
40864 wxMenu *arg1 = (wxMenu *) 0 ;
40865 wxMenu *arg2 = (wxMenu *) 0 ;
40866 void *argp1 = 0 ;
40867 int res1 = 0 ;
40868 void *argp2 = 0 ;
40869 int res2 = 0 ;
40870 PyObject * obj0 = 0 ;
40871 PyObject * obj1 = 0 ;
40872 char * kwnames[] = {
40873 (char *) "self",(char *) "parent", NULL
40874 };
40875
40876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40878 if (!SWIG_IsOK(res1)) {
40879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40880 }
40881 arg1 = reinterpret_cast< wxMenu * >(argp1);
40882 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40883 if (!SWIG_IsOK(res2)) {
40884 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40885 }
40886 arg2 = reinterpret_cast< wxMenu * >(argp2);
40887 {
40888 PyThreadState* __tstate = wxPyBeginAllowThreads();
40889 (arg1)->SetParent(arg2);
40890 wxPyEndAllowThreads(__tstate);
40891 if (PyErr_Occurred()) SWIG_fail;
40892 }
40893 resultobj = SWIG_Py_Void();
40894 return resultobj;
40895 fail:
40896 return NULL;
40897 }
40898
40899
40900 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40901 PyObject *resultobj = 0;
40902 wxMenu *arg1 = (wxMenu *) 0 ;
40903 wxMenu *result = 0 ;
40904 void *argp1 = 0 ;
40905 int res1 = 0 ;
40906 PyObject *swig_obj[1] ;
40907
40908 if (!args) SWIG_fail;
40909 swig_obj[0] = args;
40910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40911 if (!SWIG_IsOK(res1)) {
40912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40913 }
40914 arg1 = reinterpret_cast< wxMenu * >(argp1);
40915 {
40916 PyThreadState* __tstate = wxPyBeginAllowThreads();
40917 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40918 wxPyEndAllowThreads(__tstate);
40919 if (PyErr_Occurred()) SWIG_fail;
40920 }
40921 {
40922 resultobj = wxPyMake_wxObject(result, 0);
40923 }
40924 return resultobj;
40925 fail:
40926 return NULL;
40927 }
40928
40929
40930 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40931 PyObject *obj;
40932 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40933 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40934 return SWIG_Py_Void();
40935 }
40936
40937 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40938 return SWIG_Python_InitShadowInstance(args);
40939 }
40940
40941 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40942 PyObject *resultobj = 0;
40943 long arg1 = (long) 0 ;
40944 wxMenuBar *result = 0 ;
40945 long val1 ;
40946 int ecode1 = 0 ;
40947 PyObject * obj0 = 0 ;
40948 char * kwnames[] = {
40949 (char *) "style", NULL
40950 };
40951
40952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40953 if (obj0) {
40954 ecode1 = SWIG_AsVal_long(obj0, &val1);
40955 if (!SWIG_IsOK(ecode1)) {
40956 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40957 }
40958 arg1 = static_cast< long >(val1);
40959 }
40960 {
40961 if (!wxPyCheckForApp()) SWIG_fail;
40962 PyThreadState* __tstate = wxPyBeginAllowThreads();
40963 result = (wxMenuBar *)new wxMenuBar(arg1);
40964 wxPyEndAllowThreads(__tstate);
40965 if (PyErr_Occurred()) SWIG_fail;
40966 }
40967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40968 return resultobj;
40969 fail:
40970 return NULL;
40971 }
40972
40973
40974 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40975 PyObject *resultobj = 0;
40976 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40977 wxMenu *arg2 = (wxMenu *) 0 ;
40978 wxString *arg3 = 0 ;
40979 bool result;
40980 void *argp1 = 0 ;
40981 int res1 = 0 ;
40982 void *argp2 = 0 ;
40983 int res2 = 0 ;
40984 bool temp3 = false ;
40985 PyObject * obj0 = 0 ;
40986 PyObject * obj1 = 0 ;
40987 PyObject * obj2 = 0 ;
40988 char * kwnames[] = {
40989 (char *) "self",(char *) "menu",(char *) "title", NULL
40990 };
40991
40992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40994 if (!SWIG_IsOK(res1)) {
40995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40996 }
40997 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40998 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40999 if (!SWIG_IsOK(res2)) {
41000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41001 }
41002 arg2 = reinterpret_cast< wxMenu * >(argp2);
41003 {
41004 arg3 = wxString_in_helper(obj2);
41005 if (arg3 == NULL) SWIG_fail;
41006 temp3 = true;
41007 }
41008 {
41009 PyThreadState* __tstate = wxPyBeginAllowThreads();
41010 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41011 wxPyEndAllowThreads(__tstate);
41012 if (PyErr_Occurred()) SWIG_fail;
41013 }
41014 {
41015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41016 }
41017 {
41018 if (temp3)
41019 delete arg3;
41020 }
41021 return resultobj;
41022 fail:
41023 {
41024 if (temp3)
41025 delete arg3;
41026 }
41027 return NULL;
41028 }
41029
41030
41031 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41032 PyObject *resultobj = 0;
41033 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41034 size_t arg2 ;
41035 wxMenu *arg3 = (wxMenu *) 0 ;
41036 wxString *arg4 = 0 ;
41037 bool result;
41038 void *argp1 = 0 ;
41039 int res1 = 0 ;
41040 size_t val2 ;
41041 int ecode2 = 0 ;
41042 void *argp3 = 0 ;
41043 int res3 = 0 ;
41044 bool temp4 = false ;
41045 PyObject * obj0 = 0 ;
41046 PyObject * obj1 = 0 ;
41047 PyObject * obj2 = 0 ;
41048 PyObject * obj3 = 0 ;
41049 char * kwnames[] = {
41050 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41051 };
41052
41053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41055 if (!SWIG_IsOK(res1)) {
41056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41057 }
41058 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41059 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41060 if (!SWIG_IsOK(ecode2)) {
41061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41062 }
41063 arg2 = static_cast< size_t >(val2);
41064 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41065 if (!SWIG_IsOK(res3)) {
41066 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41067 }
41068 arg3 = reinterpret_cast< wxMenu * >(argp3);
41069 {
41070 arg4 = wxString_in_helper(obj3);
41071 if (arg4 == NULL) SWIG_fail;
41072 temp4 = true;
41073 }
41074 {
41075 PyThreadState* __tstate = wxPyBeginAllowThreads();
41076 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41077 wxPyEndAllowThreads(__tstate);
41078 if (PyErr_Occurred()) SWIG_fail;
41079 }
41080 {
41081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41082 }
41083 {
41084 if (temp4)
41085 delete arg4;
41086 }
41087 return resultobj;
41088 fail:
41089 {
41090 if (temp4)
41091 delete arg4;
41092 }
41093 return NULL;
41094 }
41095
41096
41097 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41098 PyObject *resultobj = 0;
41099 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41100 size_t result;
41101 void *argp1 = 0 ;
41102 int res1 = 0 ;
41103 PyObject *swig_obj[1] ;
41104
41105 if (!args) SWIG_fail;
41106 swig_obj[0] = args;
41107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41108 if (!SWIG_IsOK(res1)) {
41109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41110 }
41111 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41112 {
41113 PyThreadState* __tstate = wxPyBeginAllowThreads();
41114 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41115 wxPyEndAllowThreads(__tstate);
41116 if (PyErr_Occurred()) SWIG_fail;
41117 }
41118 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41119 return resultobj;
41120 fail:
41121 return NULL;
41122 }
41123
41124
41125 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41126 PyObject *resultobj = 0;
41127 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41128 size_t arg2 ;
41129 wxMenu *result = 0 ;
41130 void *argp1 = 0 ;
41131 int res1 = 0 ;
41132 size_t val2 ;
41133 int ecode2 = 0 ;
41134 PyObject * obj0 = 0 ;
41135 PyObject * obj1 = 0 ;
41136 char * kwnames[] = {
41137 (char *) "self",(char *) "pos", NULL
41138 };
41139
41140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41142 if (!SWIG_IsOK(res1)) {
41143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41144 }
41145 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41146 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41147 if (!SWIG_IsOK(ecode2)) {
41148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41149 }
41150 arg2 = static_cast< size_t >(val2);
41151 {
41152 PyThreadState* __tstate = wxPyBeginAllowThreads();
41153 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41154 wxPyEndAllowThreads(__tstate);
41155 if (PyErr_Occurred()) SWIG_fail;
41156 }
41157 {
41158 resultobj = wxPyMake_wxObject(result, 0);
41159 }
41160 return resultobj;
41161 fail:
41162 return NULL;
41163 }
41164
41165
41166 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41167 PyObject *resultobj = 0;
41168 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41169 size_t arg2 ;
41170 wxMenu *arg3 = (wxMenu *) 0 ;
41171 wxString *arg4 = 0 ;
41172 wxMenu *result = 0 ;
41173 void *argp1 = 0 ;
41174 int res1 = 0 ;
41175 size_t val2 ;
41176 int ecode2 = 0 ;
41177 void *argp3 = 0 ;
41178 int res3 = 0 ;
41179 bool temp4 = false ;
41180 PyObject * obj0 = 0 ;
41181 PyObject * obj1 = 0 ;
41182 PyObject * obj2 = 0 ;
41183 PyObject * obj3 = 0 ;
41184 char * kwnames[] = {
41185 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41186 };
41187
41188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41190 if (!SWIG_IsOK(res1)) {
41191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41192 }
41193 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41194 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41195 if (!SWIG_IsOK(ecode2)) {
41196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41197 }
41198 arg2 = static_cast< size_t >(val2);
41199 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41200 if (!SWIG_IsOK(res3)) {
41201 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41202 }
41203 arg3 = reinterpret_cast< wxMenu * >(argp3);
41204 {
41205 arg4 = wxString_in_helper(obj3);
41206 if (arg4 == NULL) SWIG_fail;
41207 temp4 = true;
41208 }
41209 {
41210 PyThreadState* __tstate = wxPyBeginAllowThreads();
41211 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41212 wxPyEndAllowThreads(__tstate);
41213 if (PyErr_Occurred()) SWIG_fail;
41214 }
41215 {
41216 resultobj = wxPyMake_wxObject(result, 0);
41217 }
41218 {
41219 if (temp4)
41220 delete arg4;
41221 }
41222 return resultobj;
41223 fail:
41224 {
41225 if (temp4)
41226 delete arg4;
41227 }
41228 return NULL;
41229 }
41230
41231
41232 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41233 PyObject *resultobj = 0;
41234 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41235 size_t arg2 ;
41236 wxMenu *result = 0 ;
41237 void *argp1 = 0 ;
41238 int res1 = 0 ;
41239 size_t val2 ;
41240 int ecode2 = 0 ;
41241 PyObject * obj0 = 0 ;
41242 PyObject * obj1 = 0 ;
41243 char * kwnames[] = {
41244 (char *) "self",(char *) "pos", NULL
41245 };
41246
41247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41249 if (!SWIG_IsOK(res1)) {
41250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41251 }
41252 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41253 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41254 if (!SWIG_IsOK(ecode2)) {
41255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41256 }
41257 arg2 = static_cast< size_t >(val2);
41258 {
41259 PyThreadState* __tstate = wxPyBeginAllowThreads();
41260 result = (wxMenu *)(arg1)->Remove(arg2);
41261 wxPyEndAllowThreads(__tstate);
41262 if (PyErr_Occurred()) SWIG_fail;
41263 }
41264 {
41265 resultobj = wxPyMake_wxObject(result, 0);
41266 }
41267 return resultobj;
41268 fail:
41269 return NULL;
41270 }
41271
41272
41273 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41274 PyObject *resultobj = 0;
41275 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41276 size_t arg2 ;
41277 bool arg3 ;
41278 void *argp1 = 0 ;
41279 int res1 = 0 ;
41280 size_t val2 ;
41281 int ecode2 = 0 ;
41282 bool val3 ;
41283 int ecode3 = 0 ;
41284 PyObject * obj0 = 0 ;
41285 PyObject * obj1 = 0 ;
41286 PyObject * obj2 = 0 ;
41287 char * kwnames[] = {
41288 (char *) "self",(char *) "pos",(char *) "enable", NULL
41289 };
41290
41291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41293 if (!SWIG_IsOK(res1)) {
41294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41295 }
41296 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41297 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41298 if (!SWIG_IsOK(ecode2)) {
41299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41300 }
41301 arg2 = static_cast< size_t >(val2);
41302 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41303 if (!SWIG_IsOK(ecode3)) {
41304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41305 }
41306 arg3 = static_cast< bool >(val3);
41307 {
41308 PyThreadState* __tstate = wxPyBeginAllowThreads();
41309 (arg1)->EnableTop(arg2,arg3);
41310 wxPyEndAllowThreads(__tstate);
41311 if (PyErr_Occurred()) SWIG_fail;
41312 }
41313 resultobj = SWIG_Py_Void();
41314 return resultobj;
41315 fail:
41316 return NULL;
41317 }
41318
41319
41320 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41321 PyObject *resultobj = 0;
41322 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41323 size_t arg2 ;
41324 bool result;
41325 void *argp1 = 0 ;
41326 int res1 = 0 ;
41327 size_t val2 ;
41328 int ecode2 = 0 ;
41329 PyObject * obj0 = 0 ;
41330 PyObject * obj1 = 0 ;
41331 char * kwnames[] = {
41332 (char *) "self",(char *) "pos", NULL
41333 };
41334
41335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41337 if (!SWIG_IsOK(res1)) {
41338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41339 }
41340 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41341 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41342 if (!SWIG_IsOK(ecode2)) {
41343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41344 }
41345 arg2 = static_cast< size_t >(val2);
41346 {
41347 PyThreadState* __tstate = wxPyBeginAllowThreads();
41348 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41349 wxPyEndAllowThreads(__tstate);
41350 if (PyErr_Occurred()) SWIG_fail;
41351 }
41352 {
41353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41354 }
41355 return resultobj;
41356 fail:
41357 return NULL;
41358 }
41359
41360
41361 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41362 PyObject *resultobj = 0;
41363 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41364 size_t arg2 ;
41365 wxString *arg3 = 0 ;
41366 void *argp1 = 0 ;
41367 int res1 = 0 ;
41368 size_t val2 ;
41369 int ecode2 = 0 ;
41370 bool temp3 = false ;
41371 PyObject * obj0 = 0 ;
41372 PyObject * obj1 = 0 ;
41373 PyObject * obj2 = 0 ;
41374 char * kwnames[] = {
41375 (char *) "self",(char *) "pos",(char *) "label", NULL
41376 };
41377
41378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41380 if (!SWIG_IsOK(res1)) {
41381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41382 }
41383 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41384 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41385 if (!SWIG_IsOK(ecode2)) {
41386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41387 }
41388 arg2 = static_cast< size_t >(val2);
41389 {
41390 arg3 = wxString_in_helper(obj2);
41391 if (arg3 == NULL) SWIG_fail;
41392 temp3 = true;
41393 }
41394 {
41395 PyThreadState* __tstate = wxPyBeginAllowThreads();
41396 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41397 wxPyEndAllowThreads(__tstate);
41398 if (PyErr_Occurred()) SWIG_fail;
41399 }
41400 resultobj = SWIG_Py_Void();
41401 {
41402 if (temp3)
41403 delete arg3;
41404 }
41405 return resultobj;
41406 fail:
41407 {
41408 if (temp3)
41409 delete arg3;
41410 }
41411 return NULL;
41412 }
41413
41414
41415 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41416 PyObject *resultobj = 0;
41417 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41418 size_t arg2 ;
41419 wxString result;
41420 void *argp1 = 0 ;
41421 int res1 = 0 ;
41422 size_t val2 ;
41423 int ecode2 = 0 ;
41424 PyObject * obj0 = 0 ;
41425 PyObject * obj1 = 0 ;
41426 char * kwnames[] = {
41427 (char *) "self",(char *) "pos", NULL
41428 };
41429
41430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41432 if (!SWIG_IsOK(res1)) {
41433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41434 }
41435 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41436 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41437 if (!SWIG_IsOK(ecode2)) {
41438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41439 }
41440 arg2 = static_cast< size_t >(val2);
41441 {
41442 PyThreadState* __tstate = wxPyBeginAllowThreads();
41443 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41444 wxPyEndAllowThreads(__tstate);
41445 if (PyErr_Occurred()) SWIG_fail;
41446 }
41447 {
41448 #if wxUSE_UNICODE
41449 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41450 #else
41451 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41452 #endif
41453 }
41454 return resultobj;
41455 fail:
41456 return NULL;
41457 }
41458
41459
41460 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41461 PyObject *resultobj = 0;
41462 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41463 wxString *arg2 = 0 ;
41464 wxString *arg3 = 0 ;
41465 int result;
41466 void *argp1 = 0 ;
41467 int res1 = 0 ;
41468 bool temp2 = false ;
41469 bool temp3 = false ;
41470 PyObject * obj0 = 0 ;
41471 PyObject * obj1 = 0 ;
41472 PyObject * obj2 = 0 ;
41473 char * kwnames[] = {
41474 (char *) "self",(char *) "menu",(char *) "item", NULL
41475 };
41476
41477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41479 if (!SWIG_IsOK(res1)) {
41480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41481 }
41482 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41483 {
41484 arg2 = wxString_in_helper(obj1);
41485 if (arg2 == NULL) SWIG_fail;
41486 temp2 = true;
41487 }
41488 {
41489 arg3 = wxString_in_helper(obj2);
41490 if (arg3 == NULL) SWIG_fail;
41491 temp3 = true;
41492 }
41493 {
41494 PyThreadState* __tstate = wxPyBeginAllowThreads();
41495 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41496 wxPyEndAllowThreads(__tstate);
41497 if (PyErr_Occurred()) SWIG_fail;
41498 }
41499 resultobj = SWIG_From_int(static_cast< int >(result));
41500 {
41501 if (temp2)
41502 delete arg2;
41503 }
41504 {
41505 if (temp3)
41506 delete arg3;
41507 }
41508 return resultobj;
41509 fail:
41510 {
41511 if (temp2)
41512 delete arg2;
41513 }
41514 {
41515 if (temp3)
41516 delete arg3;
41517 }
41518 return NULL;
41519 }
41520
41521
41522 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41523 PyObject *resultobj = 0;
41524 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41525 int arg2 ;
41526 wxMenuItem *result = 0 ;
41527 void *argp1 = 0 ;
41528 int res1 = 0 ;
41529 int val2 ;
41530 int ecode2 = 0 ;
41531 PyObject * obj0 = 0 ;
41532 PyObject * obj1 = 0 ;
41533 char * kwnames[] = {
41534 (char *) "self",(char *) "id", NULL
41535 };
41536
41537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41539 if (!SWIG_IsOK(res1)) {
41540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41541 }
41542 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41543 ecode2 = SWIG_AsVal_int(obj1, &val2);
41544 if (!SWIG_IsOK(ecode2)) {
41545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41546 }
41547 arg2 = static_cast< int >(val2);
41548 {
41549 PyThreadState* __tstate = wxPyBeginAllowThreads();
41550 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41551 wxPyEndAllowThreads(__tstate);
41552 if (PyErr_Occurred()) SWIG_fail;
41553 }
41554 {
41555 resultobj = wxPyMake_wxObject(result, (bool)0);
41556 }
41557 return resultobj;
41558 fail:
41559 return NULL;
41560 }
41561
41562
41563 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41564 PyObject *resultobj = 0;
41565 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41566 wxString *arg2 = 0 ;
41567 int result;
41568 void *argp1 = 0 ;
41569 int res1 = 0 ;
41570 bool temp2 = false ;
41571 PyObject * obj0 = 0 ;
41572 PyObject * obj1 = 0 ;
41573 char * kwnames[] = {
41574 (char *) "self",(char *) "title", NULL
41575 };
41576
41577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41579 if (!SWIG_IsOK(res1)) {
41580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41581 }
41582 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41583 {
41584 arg2 = wxString_in_helper(obj1);
41585 if (arg2 == NULL) SWIG_fail;
41586 temp2 = true;
41587 }
41588 {
41589 PyThreadState* __tstate = wxPyBeginAllowThreads();
41590 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41591 wxPyEndAllowThreads(__tstate);
41592 if (PyErr_Occurred()) SWIG_fail;
41593 }
41594 resultobj = SWIG_From_int(static_cast< int >(result));
41595 {
41596 if (temp2)
41597 delete arg2;
41598 }
41599 return resultobj;
41600 fail:
41601 {
41602 if (temp2)
41603 delete arg2;
41604 }
41605 return NULL;
41606 }
41607
41608
41609 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41610 PyObject *resultobj = 0;
41611 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41612 int arg2 ;
41613 bool arg3 ;
41614 void *argp1 = 0 ;
41615 int res1 = 0 ;
41616 int val2 ;
41617 int ecode2 = 0 ;
41618 bool val3 ;
41619 int ecode3 = 0 ;
41620 PyObject * obj0 = 0 ;
41621 PyObject * obj1 = 0 ;
41622 PyObject * obj2 = 0 ;
41623 char * kwnames[] = {
41624 (char *) "self",(char *) "id",(char *) "enable", NULL
41625 };
41626
41627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41629 if (!SWIG_IsOK(res1)) {
41630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41631 }
41632 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41633 ecode2 = SWIG_AsVal_int(obj1, &val2);
41634 if (!SWIG_IsOK(ecode2)) {
41635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41636 }
41637 arg2 = static_cast< int >(val2);
41638 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41639 if (!SWIG_IsOK(ecode3)) {
41640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41641 }
41642 arg3 = static_cast< bool >(val3);
41643 {
41644 PyThreadState* __tstate = wxPyBeginAllowThreads();
41645 (arg1)->Enable(arg2,arg3);
41646 wxPyEndAllowThreads(__tstate);
41647 if (PyErr_Occurred()) SWIG_fail;
41648 }
41649 resultobj = SWIG_Py_Void();
41650 return resultobj;
41651 fail:
41652 return NULL;
41653 }
41654
41655
41656 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41657 PyObject *resultobj = 0;
41658 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41659 int arg2 ;
41660 bool arg3 ;
41661 void *argp1 = 0 ;
41662 int res1 = 0 ;
41663 int val2 ;
41664 int ecode2 = 0 ;
41665 bool val3 ;
41666 int ecode3 = 0 ;
41667 PyObject * obj0 = 0 ;
41668 PyObject * obj1 = 0 ;
41669 PyObject * obj2 = 0 ;
41670 char * kwnames[] = {
41671 (char *) "self",(char *) "id",(char *) "check", NULL
41672 };
41673
41674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41676 if (!SWIG_IsOK(res1)) {
41677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41678 }
41679 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41680 ecode2 = SWIG_AsVal_int(obj1, &val2);
41681 if (!SWIG_IsOK(ecode2)) {
41682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41683 }
41684 arg2 = static_cast< int >(val2);
41685 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41686 if (!SWIG_IsOK(ecode3)) {
41687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41688 }
41689 arg3 = static_cast< bool >(val3);
41690 {
41691 PyThreadState* __tstate = wxPyBeginAllowThreads();
41692 (arg1)->Check(arg2,arg3);
41693 wxPyEndAllowThreads(__tstate);
41694 if (PyErr_Occurred()) SWIG_fail;
41695 }
41696 resultobj = SWIG_Py_Void();
41697 return resultobj;
41698 fail:
41699 return NULL;
41700 }
41701
41702
41703 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41704 PyObject *resultobj = 0;
41705 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41706 int arg2 ;
41707 bool result;
41708 void *argp1 = 0 ;
41709 int res1 = 0 ;
41710 int val2 ;
41711 int ecode2 = 0 ;
41712 PyObject * obj0 = 0 ;
41713 PyObject * obj1 = 0 ;
41714 char * kwnames[] = {
41715 (char *) "self",(char *) "id", NULL
41716 };
41717
41718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41720 if (!SWIG_IsOK(res1)) {
41721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41722 }
41723 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41724 ecode2 = SWIG_AsVal_int(obj1, &val2);
41725 if (!SWIG_IsOK(ecode2)) {
41726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41727 }
41728 arg2 = static_cast< int >(val2);
41729 {
41730 PyThreadState* __tstate = wxPyBeginAllowThreads();
41731 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41732 wxPyEndAllowThreads(__tstate);
41733 if (PyErr_Occurred()) SWIG_fail;
41734 }
41735 {
41736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41737 }
41738 return resultobj;
41739 fail:
41740 return NULL;
41741 }
41742
41743
41744 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41745 PyObject *resultobj = 0;
41746 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41747 int arg2 ;
41748 bool result;
41749 void *argp1 = 0 ;
41750 int res1 = 0 ;
41751 int val2 ;
41752 int ecode2 = 0 ;
41753 PyObject * obj0 = 0 ;
41754 PyObject * obj1 = 0 ;
41755 char * kwnames[] = {
41756 (char *) "self",(char *) "id", NULL
41757 };
41758
41759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41761 if (!SWIG_IsOK(res1)) {
41762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41763 }
41764 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41765 ecode2 = SWIG_AsVal_int(obj1, &val2);
41766 if (!SWIG_IsOK(ecode2)) {
41767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41768 }
41769 arg2 = static_cast< int >(val2);
41770 {
41771 PyThreadState* __tstate = wxPyBeginAllowThreads();
41772 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41773 wxPyEndAllowThreads(__tstate);
41774 if (PyErr_Occurred()) SWIG_fail;
41775 }
41776 {
41777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41778 }
41779 return resultobj;
41780 fail:
41781 return NULL;
41782 }
41783
41784
41785 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41786 PyObject *resultobj = 0;
41787 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41788 int arg2 ;
41789 wxString *arg3 = 0 ;
41790 void *argp1 = 0 ;
41791 int res1 = 0 ;
41792 int val2 ;
41793 int ecode2 = 0 ;
41794 bool temp3 = false ;
41795 PyObject * obj0 = 0 ;
41796 PyObject * obj1 = 0 ;
41797 PyObject * obj2 = 0 ;
41798 char * kwnames[] = {
41799 (char *) "self",(char *) "id",(char *) "label", NULL
41800 };
41801
41802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41804 if (!SWIG_IsOK(res1)) {
41805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41806 }
41807 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41808 ecode2 = SWIG_AsVal_int(obj1, &val2);
41809 if (!SWIG_IsOK(ecode2)) {
41810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41811 }
41812 arg2 = static_cast< int >(val2);
41813 {
41814 arg3 = wxString_in_helper(obj2);
41815 if (arg3 == NULL) SWIG_fail;
41816 temp3 = true;
41817 }
41818 {
41819 PyThreadState* __tstate = wxPyBeginAllowThreads();
41820 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41821 wxPyEndAllowThreads(__tstate);
41822 if (PyErr_Occurred()) SWIG_fail;
41823 }
41824 resultobj = SWIG_Py_Void();
41825 {
41826 if (temp3)
41827 delete arg3;
41828 }
41829 return resultobj;
41830 fail:
41831 {
41832 if (temp3)
41833 delete arg3;
41834 }
41835 return NULL;
41836 }
41837
41838
41839 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41840 PyObject *resultobj = 0;
41841 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41842 int arg2 ;
41843 wxString result;
41844 void *argp1 = 0 ;
41845 int res1 = 0 ;
41846 int val2 ;
41847 int ecode2 = 0 ;
41848 PyObject * obj0 = 0 ;
41849 PyObject * obj1 = 0 ;
41850 char * kwnames[] = {
41851 (char *) "self",(char *) "id", NULL
41852 };
41853
41854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41856 if (!SWIG_IsOK(res1)) {
41857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41858 }
41859 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41860 ecode2 = SWIG_AsVal_int(obj1, &val2);
41861 if (!SWIG_IsOK(ecode2)) {
41862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41863 }
41864 arg2 = static_cast< int >(val2);
41865 {
41866 PyThreadState* __tstate = wxPyBeginAllowThreads();
41867 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41868 wxPyEndAllowThreads(__tstate);
41869 if (PyErr_Occurred()) SWIG_fail;
41870 }
41871 {
41872 #if wxUSE_UNICODE
41873 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41874 #else
41875 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41876 #endif
41877 }
41878 return resultobj;
41879 fail:
41880 return NULL;
41881 }
41882
41883
41884 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41885 PyObject *resultobj = 0;
41886 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41887 int arg2 ;
41888 wxString *arg3 = 0 ;
41889 void *argp1 = 0 ;
41890 int res1 = 0 ;
41891 int val2 ;
41892 int ecode2 = 0 ;
41893 bool temp3 = false ;
41894 PyObject * obj0 = 0 ;
41895 PyObject * obj1 = 0 ;
41896 PyObject * obj2 = 0 ;
41897 char * kwnames[] = {
41898 (char *) "self",(char *) "id",(char *) "helpString", NULL
41899 };
41900
41901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41903 if (!SWIG_IsOK(res1)) {
41904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41905 }
41906 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41907 ecode2 = SWIG_AsVal_int(obj1, &val2);
41908 if (!SWIG_IsOK(ecode2)) {
41909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41910 }
41911 arg2 = static_cast< int >(val2);
41912 {
41913 arg3 = wxString_in_helper(obj2);
41914 if (arg3 == NULL) SWIG_fail;
41915 temp3 = true;
41916 }
41917 {
41918 PyThreadState* __tstate = wxPyBeginAllowThreads();
41919 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41920 wxPyEndAllowThreads(__tstate);
41921 if (PyErr_Occurred()) SWIG_fail;
41922 }
41923 resultobj = SWIG_Py_Void();
41924 {
41925 if (temp3)
41926 delete arg3;
41927 }
41928 return resultobj;
41929 fail:
41930 {
41931 if (temp3)
41932 delete arg3;
41933 }
41934 return NULL;
41935 }
41936
41937
41938 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41939 PyObject *resultobj = 0;
41940 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41941 int arg2 ;
41942 wxString result;
41943 void *argp1 = 0 ;
41944 int res1 = 0 ;
41945 int val2 ;
41946 int ecode2 = 0 ;
41947 PyObject * obj0 = 0 ;
41948 PyObject * obj1 = 0 ;
41949 char * kwnames[] = {
41950 (char *) "self",(char *) "id", NULL
41951 };
41952
41953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41955 if (!SWIG_IsOK(res1)) {
41956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41957 }
41958 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41959 ecode2 = SWIG_AsVal_int(obj1, &val2);
41960 if (!SWIG_IsOK(ecode2)) {
41961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41962 }
41963 arg2 = static_cast< int >(val2);
41964 {
41965 PyThreadState* __tstate = wxPyBeginAllowThreads();
41966 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41967 wxPyEndAllowThreads(__tstate);
41968 if (PyErr_Occurred()) SWIG_fail;
41969 }
41970 {
41971 #if wxUSE_UNICODE
41972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41973 #else
41974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41975 #endif
41976 }
41977 return resultobj;
41978 fail:
41979 return NULL;
41980 }
41981
41982
41983 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41984 PyObject *resultobj = 0;
41985 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41986 wxFrame *result = 0 ;
41987 void *argp1 = 0 ;
41988 int res1 = 0 ;
41989 PyObject *swig_obj[1] ;
41990
41991 if (!args) SWIG_fail;
41992 swig_obj[0] = args;
41993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41994 if (!SWIG_IsOK(res1)) {
41995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41996 }
41997 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41998 {
41999 PyThreadState* __tstate = wxPyBeginAllowThreads();
42000 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42001 wxPyEndAllowThreads(__tstate);
42002 if (PyErr_Occurred()) SWIG_fail;
42003 }
42004 {
42005 resultobj = wxPyMake_wxObject(result, (bool)0);
42006 }
42007 return resultobj;
42008 fail:
42009 return NULL;
42010 }
42011
42012
42013 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42014 PyObject *resultobj = 0;
42015 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42016 bool result;
42017 void *argp1 = 0 ;
42018 int res1 = 0 ;
42019 PyObject *swig_obj[1] ;
42020
42021 if (!args) SWIG_fail;
42022 swig_obj[0] = args;
42023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42024 if (!SWIG_IsOK(res1)) {
42025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42026 }
42027 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42028 {
42029 PyThreadState* __tstate = wxPyBeginAllowThreads();
42030 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42031 wxPyEndAllowThreads(__tstate);
42032 if (PyErr_Occurred()) SWIG_fail;
42033 }
42034 {
42035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42036 }
42037 return resultobj;
42038 fail:
42039 return NULL;
42040 }
42041
42042
42043 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42044 PyObject *resultobj = 0;
42045 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42046 wxFrame *arg2 = (wxFrame *) 0 ;
42047 void *argp1 = 0 ;
42048 int res1 = 0 ;
42049 void *argp2 = 0 ;
42050 int res2 = 0 ;
42051 PyObject * obj0 = 0 ;
42052 PyObject * obj1 = 0 ;
42053 char * kwnames[] = {
42054 (char *) "self",(char *) "frame", NULL
42055 };
42056
42057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42059 if (!SWIG_IsOK(res1)) {
42060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42061 }
42062 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42063 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42064 if (!SWIG_IsOK(res2)) {
42065 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42066 }
42067 arg2 = reinterpret_cast< wxFrame * >(argp2);
42068 {
42069 PyThreadState* __tstate = wxPyBeginAllowThreads();
42070 (arg1)->Attach(arg2);
42071 wxPyEndAllowThreads(__tstate);
42072 if (PyErr_Occurred()) SWIG_fail;
42073 }
42074 resultobj = SWIG_Py_Void();
42075 return resultobj;
42076 fail:
42077 return NULL;
42078 }
42079
42080
42081 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42082 PyObject *resultobj = 0;
42083 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42084 void *argp1 = 0 ;
42085 int res1 = 0 ;
42086 PyObject *swig_obj[1] ;
42087
42088 if (!args) SWIG_fail;
42089 swig_obj[0] = args;
42090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42091 if (!SWIG_IsOK(res1)) {
42092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42093 }
42094 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42095 {
42096 PyThreadState* __tstate = wxPyBeginAllowThreads();
42097 (arg1)->Detach();
42098 wxPyEndAllowThreads(__tstate);
42099 if (PyErr_Occurred()) SWIG_fail;
42100 }
42101 resultobj = SWIG_Py_Void();
42102 return resultobj;
42103 fail:
42104 return NULL;
42105 }
42106
42107
42108 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42109 PyObject *resultobj = 0;
42110 bool arg1 ;
42111 bool val1 ;
42112 int ecode1 = 0 ;
42113 PyObject * obj0 = 0 ;
42114 char * kwnames[] = {
42115 (char *) "enable", NULL
42116 };
42117
42118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42119 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42120 if (!SWIG_IsOK(ecode1)) {
42121 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42122 }
42123 arg1 = static_cast< bool >(val1);
42124 {
42125 PyThreadState* __tstate = wxPyBeginAllowThreads();
42126 wxMenuBar::SetAutoWindowMenu(arg1);
42127 wxPyEndAllowThreads(__tstate);
42128 if (PyErr_Occurred()) SWIG_fail;
42129 }
42130 resultobj = SWIG_Py_Void();
42131 return resultobj;
42132 fail:
42133 return NULL;
42134 }
42135
42136
42137 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42138 PyObject *resultobj = 0;
42139 bool result;
42140
42141 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42142 {
42143 PyThreadState* __tstate = wxPyBeginAllowThreads();
42144 result = (bool)wxMenuBar::GetAutoWindowMenu();
42145 wxPyEndAllowThreads(__tstate);
42146 if (PyErr_Occurred()) SWIG_fail;
42147 }
42148 {
42149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42150 }
42151 return resultobj;
42152 fail:
42153 return NULL;
42154 }
42155
42156
42157 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42158 PyObject *obj;
42159 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42160 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42161 return SWIG_Py_Void();
42162 }
42163
42164 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42165 return SWIG_Python_InitShadowInstance(args);
42166 }
42167
42168 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42169 PyObject *resultobj = 0;
42170 wxMenu *arg1 = (wxMenu *) NULL ;
42171 int arg2 = (int) wxID_ANY ;
42172 wxString const &arg3_defvalue = wxPyEmptyString ;
42173 wxString *arg3 = (wxString *) &arg3_defvalue ;
42174 wxString const &arg4_defvalue = wxPyEmptyString ;
42175 wxString *arg4 = (wxString *) &arg4_defvalue ;
42176 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42177 wxMenu *arg6 = (wxMenu *) NULL ;
42178 wxMenuItem *result = 0 ;
42179 void *argp1 = 0 ;
42180 int res1 = 0 ;
42181 int val2 ;
42182 int ecode2 = 0 ;
42183 bool temp3 = false ;
42184 bool temp4 = false ;
42185 int val5 ;
42186 int ecode5 = 0 ;
42187 void *argp6 = 0 ;
42188 int res6 = 0 ;
42189 PyObject * obj0 = 0 ;
42190 PyObject * obj1 = 0 ;
42191 PyObject * obj2 = 0 ;
42192 PyObject * obj3 = 0 ;
42193 PyObject * obj4 = 0 ;
42194 PyObject * obj5 = 0 ;
42195 char * kwnames[] = {
42196 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42197 };
42198
42199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42200 if (obj0) {
42201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42202 if (!SWIG_IsOK(res1)) {
42203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42204 }
42205 arg1 = reinterpret_cast< wxMenu * >(argp1);
42206 }
42207 if (obj1) {
42208 ecode2 = SWIG_AsVal_int(obj1, &val2);
42209 if (!SWIG_IsOK(ecode2)) {
42210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42211 }
42212 arg2 = static_cast< int >(val2);
42213 }
42214 if (obj2) {
42215 {
42216 arg3 = wxString_in_helper(obj2);
42217 if (arg3 == NULL) SWIG_fail;
42218 temp3 = true;
42219 }
42220 }
42221 if (obj3) {
42222 {
42223 arg4 = wxString_in_helper(obj3);
42224 if (arg4 == NULL) SWIG_fail;
42225 temp4 = true;
42226 }
42227 }
42228 if (obj4) {
42229 ecode5 = SWIG_AsVal_int(obj4, &val5);
42230 if (!SWIG_IsOK(ecode5)) {
42231 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42232 }
42233 arg5 = static_cast< wxItemKind >(val5);
42234 }
42235 if (obj5) {
42236 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42237 if (!SWIG_IsOK(res6)) {
42238 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42239 }
42240 arg6 = reinterpret_cast< wxMenu * >(argp6);
42241 }
42242 {
42243 PyThreadState* __tstate = wxPyBeginAllowThreads();
42244 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42245 wxPyEndAllowThreads(__tstate);
42246 if (PyErr_Occurred()) SWIG_fail;
42247 }
42248 {
42249 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42250 }
42251 {
42252 if (temp3)
42253 delete arg3;
42254 }
42255 {
42256 if (temp4)
42257 delete arg4;
42258 }
42259 return resultobj;
42260 fail:
42261 {
42262 if (temp3)
42263 delete arg3;
42264 }
42265 {
42266 if (temp4)
42267 delete arg4;
42268 }
42269 return NULL;
42270 }
42271
42272
42273 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42274 PyObject *resultobj = 0;
42275 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42276 void *argp1 = 0 ;
42277 int res1 = 0 ;
42278 PyObject *swig_obj[1] ;
42279
42280 if (!args) SWIG_fail;
42281 swig_obj[0] = args;
42282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42283 if (!SWIG_IsOK(res1)) {
42284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42285 }
42286 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42287 {
42288 PyThreadState* __tstate = wxPyBeginAllowThreads();
42289 delete arg1;
42290
42291 wxPyEndAllowThreads(__tstate);
42292 if (PyErr_Occurred()) SWIG_fail;
42293 }
42294 resultobj = SWIG_Py_Void();
42295 return resultobj;
42296 fail:
42297 return NULL;
42298 }
42299
42300
42301 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42302 PyObject *resultobj = 0;
42303 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42304 wxMenu *result = 0 ;
42305 void *argp1 = 0 ;
42306 int res1 = 0 ;
42307 PyObject *swig_obj[1] ;
42308
42309 if (!args) SWIG_fail;
42310 swig_obj[0] = args;
42311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42312 if (!SWIG_IsOK(res1)) {
42313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42314 }
42315 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42316 {
42317 PyThreadState* __tstate = wxPyBeginAllowThreads();
42318 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42319 wxPyEndAllowThreads(__tstate);
42320 if (PyErr_Occurred()) SWIG_fail;
42321 }
42322 {
42323 resultobj = wxPyMake_wxObject(result, 0);
42324 }
42325 return resultobj;
42326 fail:
42327 return NULL;
42328 }
42329
42330
42331 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42332 PyObject *resultobj = 0;
42333 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42334 wxMenu *arg2 = (wxMenu *) 0 ;
42335 void *argp1 = 0 ;
42336 int res1 = 0 ;
42337 void *argp2 = 0 ;
42338 int res2 = 0 ;
42339 PyObject * obj0 = 0 ;
42340 PyObject * obj1 = 0 ;
42341 char * kwnames[] = {
42342 (char *) "self",(char *) "menu", NULL
42343 };
42344
42345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42347 if (!SWIG_IsOK(res1)) {
42348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42349 }
42350 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42351 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42352 if (!SWIG_IsOK(res2)) {
42353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42354 }
42355 arg2 = reinterpret_cast< wxMenu * >(argp2);
42356 {
42357 PyThreadState* __tstate = wxPyBeginAllowThreads();
42358 (arg1)->SetMenu(arg2);
42359 wxPyEndAllowThreads(__tstate);
42360 if (PyErr_Occurred()) SWIG_fail;
42361 }
42362 resultobj = SWIG_Py_Void();
42363 return resultobj;
42364 fail:
42365 return NULL;
42366 }
42367
42368
42369 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42370 PyObject *resultobj = 0;
42371 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42372 int arg2 ;
42373 void *argp1 = 0 ;
42374 int res1 = 0 ;
42375 int val2 ;
42376 int ecode2 = 0 ;
42377 PyObject * obj0 = 0 ;
42378 PyObject * obj1 = 0 ;
42379 char * kwnames[] = {
42380 (char *) "self",(char *) "id", NULL
42381 };
42382
42383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42385 if (!SWIG_IsOK(res1)) {
42386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42387 }
42388 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42389 ecode2 = SWIG_AsVal_int(obj1, &val2);
42390 if (!SWIG_IsOK(ecode2)) {
42391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42392 }
42393 arg2 = static_cast< int >(val2);
42394 {
42395 PyThreadState* __tstate = wxPyBeginAllowThreads();
42396 (arg1)->SetId(arg2);
42397 wxPyEndAllowThreads(__tstate);
42398 if (PyErr_Occurred()) SWIG_fail;
42399 }
42400 resultobj = SWIG_Py_Void();
42401 return resultobj;
42402 fail:
42403 return NULL;
42404 }
42405
42406
42407 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42408 PyObject *resultobj = 0;
42409 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42410 int result;
42411 void *argp1 = 0 ;
42412 int res1 = 0 ;
42413 PyObject *swig_obj[1] ;
42414
42415 if (!args) SWIG_fail;
42416 swig_obj[0] = args;
42417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42418 if (!SWIG_IsOK(res1)) {
42419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42420 }
42421 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42422 {
42423 PyThreadState* __tstate = wxPyBeginAllowThreads();
42424 result = (int)((wxMenuItem const *)arg1)->GetId();
42425 wxPyEndAllowThreads(__tstate);
42426 if (PyErr_Occurred()) SWIG_fail;
42427 }
42428 resultobj = SWIG_From_int(static_cast< int >(result));
42429 return resultobj;
42430 fail:
42431 return NULL;
42432 }
42433
42434
42435 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42436 PyObject *resultobj = 0;
42437 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42438 bool result;
42439 void *argp1 = 0 ;
42440 int res1 = 0 ;
42441 PyObject *swig_obj[1] ;
42442
42443 if (!args) SWIG_fail;
42444 swig_obj[0] = args;
42445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42446 if (!SWIG_IsOK(res1)) {
42447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42448 }
42449 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42450 {
42451 PyThreadState* __tstate = wxPyBeginAllowThreads();
42452 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42453 wxPyEndAllowThreads(__tstate);
42454 if (PyErr_Occurred()) SWIG_fail;
42455 }
42456 {
42457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42458 }
42459 return resultobj;
42460 fail:
42461 return NULL;
42462 }
42463
42464
42465 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42466 PyObject *resultobj = 0;
42467 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42468 wxString *arg2 = 0 ;
42469 void *argp1 = 0 ;
42470 int res1 = 0 ;
42471 bool temp2 = false ;
42472 PyObject * obj0 = 0 ;
42473 PyObject * obj1 = 0 ;
42474 char * kwnames[] = {
42475 (char *) "self",(char *) "str", NULL
42476 };
42477
42478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42480 if (!SWIG_IsOK(res1)) {
42481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42482 }
42483 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42484 {
42485 arg2 = wxString_in_helper(obj1);
42486 if (arg2 == NULL) SWIG_fail;
42487 temp2 = true;
42488 }
42489 {
42490 PyThreadState* __tstate = wxPyBeginAllowThreads();
42491 (arg1)->SetText((wxString const &)*arg2);
42492 wxPyEndAllowThreads(__tstate);
42493 if (PyErr_Occurred()) SWIG_fail;
42494 }
42495 resultobj = SWIG_Py_Void();
42496 {
42497 if (temp2)
42498 delete arg2;
42499 }
42500 return resultobj;
42501 fail:
42502 {
42503 if (temp2)
42504 delete arg2;
42505 }
42506 return NULL;
42507 }
42508
42509
42510 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42511 PyObject *resultobj = 0;
42512 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42513 wxString result;
42514 void *argp1 = 0 ;
42515 int res1 = 0 ;
42516 PyObject *swig_obj[1] ;
42517
42518 if (!args) SWIG_fail;
42519 swig_obj[0] = args;
42520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42521 if (!SWIG_IsOK(res1)) {
42522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42523 }
42524 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42525 {
42526 PyThreadState* __tstate = wxPyBeginAllowThreads();
42527 result = ((wxMenuItem const *)arg1)->GetLabel();
42528 wxPyEndAllowThreads(__tstate);
42529 if (PyErr_Occurred()) SWIG_fail;
42530 }
42531 {
42532 #if wxUSE_UNICODE
42533 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42534 #else
42535 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42536 #endif
42537 }
42538 return resultobj;
42539 fail:
42540 return NULL;
42541 }
42542
42543
42544 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42545 PyObject *resultobj = 0;
42546 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42547 wxString *result = 0 ;
42548 void *argp1 = 0 ;
42549 int res1 = 0 ;
42550 PyObject *swig_obj[1] ;
42551
42552 if (!args) SWIG_fail;
42553 swig_obj[0] = args;
42554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42555 if (!SWIG_IsOK(res1)) {
42556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42557 }
42558 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42559 {
42560 PyThreadState* __tstate = wxPyBeginAllowThreads();
42561 {
42562 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42563 result = (wxString *) &_result_ref;
42564 }
42565 wxPyEndAllowThreads(__tstate);
42566 if (PyErr_Occurred()) SWIG_fail;
42567 }
42568 {
42569 #if wxUSE_UNICODE
42570 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42571 #else
42572 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42573 #endif
42574 }
42575 return resultobj;
42576 fail:
42577 return NULL;
42578 }
42579
42580
42581 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42582 PyObject *resultobj = 0;
42583 wxString *arg1 = 0 ;
42584 wxString result;
42585 bool temp1 = false ;
42586 PyObject * obj0 = 0 ;
42587 char * kwnames[] = {
42588 (char *) "text", NULL
42589 };
42590
42591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42592 {
42593 arg1 = wxString_in_helper(obj0);
42594 if (arg1 == NULL) SWIG_fail;
42595 temp1 = true;
42596 }
42597 {
42598 PyThreadState* __tstate = wxPyBeginAllowThreads();
42599 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42600 wxPyEndAllowThreads(__tstate);
42601 if (PyErr_Occurred()) SWIG_fail;
42602 }
42603 {
42604 #if wxUSE_UNICODE
42605 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42606 #else
42607 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42608 #endif
42609 }
42610 {
42611 if (temp1)
42612 delete arg1;
42613 }
42614 return resultobj;
42615 fail:
42616 {
42617 if (temp1)
42618 delete arg1;
42619 }
42620 return NULL;
42621 }
42622
42623
42624 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42625 PyObject *resultobj = 0;
42626 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42627 wxItemKind result;
42628 void *argp1 = 0 ;
42629 int res1 = 0 ;
42630 PyObject *swig_obj[1] ;
42631
42632 if (!args) SWIG_fail;
42633 swig_obj[0] = args;
42634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42635 if (!SWIG_IsOK(res1)) {
42636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42637 }
42638 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42639 {
42640 PyThreadState* __tstate = wxPyBeginAllowThreads();
42641 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42642 wxPyEndAllowThreads(__tstate);
42643 if (PyErr_Occurred()) SWIG_fail;
42644 }
42645 resultobj = SWIG_From_int(static_cast< int >(result));
42646 return resultobj;
42647 fail:
42648 return NULL;
42649 }
42650
42651
42652 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42653 PyObject *resultobj = 0;
42654 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42655 wxItemKind arg2 ;
42656 void *argp1 = 0 ;
42657 int res1 = 0 ;
42658 int val2 ;
42659 int ecode2 = 0 ;
42660 PyObject * obj0 = 0 ;
42661 PyObject * obj1 = 0 ;
42662 char * kwnames[] = {
42663 (char *) "self",(char *) "kind", NULL
42664 };
42665
42666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42668 if (!SWIG_IsOK(res1)) {
42669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42670 }
42671 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42672 ecode2 = SWIG_AsVal_int(obj1, &val2);
42673 if (!SWIG_IsOK(ecode2)) {
42674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42675 }
42676 arg2 = static_cast< wxItemKind >(val2);
42677 {
42678 PyThreadState* __tstate = wxPyBeginAllowThreads();
42679 (arg1)->SetKind(arg2);
42680 wxPyEndAllowThreads(__tstate);
42681 if (PyErr_Occurred()) SWIG_fail;
42682 }
42683 resultobj = SWIG_Py_Void();
42684 return resultobj;
42685 fail:
42686 return NULL;
42687 }
42688
42689
42690 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42691 PyObject *resultobj = 0;
42692 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42693 bool arg2 ;
42694 void *argp1 = 0 ;
42695 int res1 = 0 ;
42696 bool val2 ;
42697 int ecode2 = 0 ;
42698 PyObject * obj0 = 0 ;
42699 PyObject * obj1 = 0 ;
42700 char * kwnames[] = {
42701 (char *) "self",(char *) "checkable", NULL
42702 };
42703
42704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42706 if (!SWIG_IsOK(res1)) {
42707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42708 }
42709 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42710 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42711 if (!SWIG_IsOK(ecode2)) {
42712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42713 }
42714 arg2 = static_cast< bool >(val2);
42715 {
42716 PyThreadState* __tstate = wxPyBeginAllowThreads();
42717 (arg1)->SetCheckable(arg2);
42718 wxPyEndAllowThreads(__tstate);
42719 if (PyErr_Occurred()) SWIG_fail;
42720 }
42721 resultobj = SWIG_Py_Void();
42722 return resultobj;
42723 fail:
42724 return NULL;
42725 }
42726
42727
42728 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42729 PyObject *resultobj = 0;
42730 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42731 bool result;
42732 void *argp1 = 0 ;
42733 int res1 = 0 ;
42734 PyObject *swig_obj[1] ;
42735
42736 if (!args) SWIG_fail;
42737 swig_obj[0] = args;
42738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42739 if (!SWIG_IsOK(res1)) {
42740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42741 }
42742 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42743 {
42744 PyThreadState* __tstate = wxPyBeginAllowThreads();
42745 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42746 wxPyEndAllowThreads(__tstate);
42747 if (PyErr_Occurred()) SWIG_fail;
42748 }
42749 {
42750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42751 }
42752 return resultobj;
42753 fail:
42754 return NULL;
42755 }
42756
42757
42758 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42759 PyObject *resultobj = 0;
42760 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42761 bool result;
42762 void *argp1 = 0 ;
42763 int res1 = 0 ;
42764 PyObject *swig_obj[1] ;
42765
42766 if (!args) SWIG_fail;
42767 swig_obj[0] = args;
42768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42769 if (!SWIG_IsOK(res1)) {
42770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42771 }
42772 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42773 {
42774 PyThreadState* __tstate = wxPyBeginAllowThreads();
42775 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42776 wxPyEndAllowThreads(__tstate);
42777 if (PyErr_Occurred()) SWIG_fail;
42778 }
42779 {
42780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42781 }
42782 return resultobj;
42783 fail:
42784 return NULL;
42785 }
42786
42787
42788 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42789 PyObject *resultobj = 0;
42790 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42791 wxMenu *arg2 = (wxMenu *) 0 ;
42792 void *argp1 = 0 ;
42793 int res1 = 0 ;
42794 void *argp2 = 0 ;
42795 int res2 = 0 ;
42796 PyObject * obj0 = 0 ;
42797 PyObject * obj1 = 0 ;
42798 char * kwnames[] = {
42799 (char *) "self",(char *) "menu", NULL
42800 };
42801
42802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42804 if (!SWIG_IsOK(res1)) {
42805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42806 }
42807 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42808 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42809 if (!SWIG_IsOK(res2)) {
42810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42811 }
42812 arg2 = reinterpret_cast< wxMenu * >(argp2);
42813 {
42814 PyThreadState* __tstate = wxPyBeginAllowThreads();
42815 (arg1)->SetSubMenu(arg2);
42816 wxPyEndAllowThreads(__tstate);
42817 if (PyErr_Occurred()) SWIG_fail;
42818 }
42819 resultobj = SWIG_Py_Void();
42820 return resultobj;
42821 fail:
42822 return NULL;
42823 }
42824
42825
42826 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42827 PyObject *resultobj = 0;
42828 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42829 wxMenu *result = 0 ;
42830 void *argp1 = 0 ;
42831 int res1 = 0 ;
42832 PyObject *swig_obj[1] ;
42833
42834 if (!args) SWIG_fail;
42835 swig_obj[0] = args;
42836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42837 if (!SWIG_IsOK(res1)) {
42838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42839 }
42840 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42841 {
42842 PyThreadState* __tstate = wxPyBeginAllowThreads();
42843 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42844 wxPyEndAllowThreads(__tstate);
42845 if (PyErr_Occurred()) SWIG_fail;
42846 }
42847 {
42848 resultobj = wxPyMake_wxObject(result, 0);
42849 }
42850 return resultobj;
42851 fail:
42852 return NULL;
42853 }
42854
42855
42856 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42857 PyObject *resultobj = 0;
42858 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42859 bool arg2 = (bool) true ;
42860 void *argp1 = 0 ;
42861 int res1 = 0 ;
42862 bool val2 ;
42863 int ecode2 = 0 ;
42864 PyObject * obj0 = 0 ;
42865 PyObject * obj1 = 0 ;
42866 char * kwnames[] = {
42867 (char *) "self",(char *) "enable", NULL
42868 };
42869
42870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42872 if (!SWIG_IsOK(res1)) {
42873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42874 }
42875 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42876 if (obj1) {
42877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42878 if (!SWIG_IsOK(ecode2)) {
42879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42880 }
42881 arg2 = static_cast< bool >(val2);
42882 }
42883 {
42884 PyThreadState* __tstate = wxPyBeginAllowThreads();
42885 (arg1)->Enable(arg2);
42886 wxPyEndAllowThreads(__tstate);
42887 if (PyErr_Occurred()) SWIG_fail;
42888 }
42889 resultobj = SWIG_Py_Void();
42890 return resultobj;
42891 fail:
42892 return NULL;
42893 }
42894
42895
42896 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42897 PyObject *resultobj = 0;
42898 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42899 bool result;
42900 void *argp1 = 0 ;
42901 int res1 = 0 ;
42902 PyObject *swig_obj[1] ;
42903
42904 if (!args) SWIG_fail;
42905 swig_obj[0] = args;
42906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42907 if (!SWIG_IsOK(res1)) {
42908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42909 }
42910 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42911 {
42912 PyThreadState* __tstate = wxPyBeginAllowThreads();
42913 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42914 wxPyEndAllowThreads(__tstate);
42915 if (PyErr_Occurred()) SWIG_fail;
42916 }
42917 {
42918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42919 }
42920 return resultobj;
42921 fail:
42922 return NULL;
42923 }
42924
42925
42926 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42927 PyObject *resultobj = 0;
42928 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42929 bool arg2 = (bool) true ;
42930 void *argp1 = 0 ;
42931 int res1 = 0 ;
42932 bool val2 ;
42933 int ecode2 = 0 ;
42934 PyObject * obj0 = 0 ;
42935 PyObject * obj1 = 0 ;
42936 char * kwnames[] = {
42937 (char *) "self",(char *) "check", NULL
42938 };
42939
42940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42942 if (!SWIG_IsOK(res1)) {
42943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42944 }
42945 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42946 if (obj1) {
42947 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42948 if (!SWIG_IsOK(ecode2)) {
42949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42950 }
42951 arg2 = static_cast< bool >(val2);
42952 }
42953 {
42954 PyThreadState* __tstate = wxPyBeginAllowThreads();
42955 (arg1)->Check(arg2);
42956 wxPyEndAllowThreads(__tstate);
42957 if (PyErr_Occurred()) SWIG_fail;
42958 }
42959 resultobj = SWIG_Py_Void();
42960 return resultobj;
42961 fail:
42962 return NULL;
42963 }
42964
42965
42966 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42967 PyObject *resultobj = 0;
42968 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42969 bool result;
42970 void *argp1 = 0 ;
42971 int res1 = 0 ;
42972 PyObject *swig_obj[1] ;
42973
42974 if (!args) SWIG_fail;
42975 swig_obj[0] = args;
42976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42977 if (!SWIG_IsOK(res1)) {
42978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42979 }
42980 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42981 {
42982 PyThreadState* __tstate = wxPyBeginAllowThreads();
42983 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42984 wxPyEndAllowThreads(__tstate);
42985 if (PyErr_Occurred()) SWIG_fail;
42986 }
42987 {
42988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42989 }
42990 return resultobj;
42991 fail:
42992 return NULL;
42993 }
42994
42995
42996 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42997 PyObject *resultobj = 0;
42998 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42999 void *argp1 = 0 ;
43000 int res1 = 0 ;
43001 PyObject *swig_obj[1] ;
43002
43003 if (!args) SWIG_fail;
43004 swig_obj[0] = args;
43005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43006 if (!SWIG_IsOK(res1)) {
43007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43008 }
43009 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43010 {
43011 PyThreadState* __tstate = wxPyBeginAllowThreads();
43012 (arg1)->Toggle();
43013 wxPyEndAllowThreads(__tstate);
43014 if (PyErr_Occurred()) SWIG_fail;
43015 }
43016 resultobj = SWIG_Py_Void();
43017 return resultobj;
43018 fail:
43019 return NULL;
43020 }
43021
43022
43023 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43024 PyObject *resultobj = 0;
43025 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43026 wxString *arg2 = 0 ;
43027 void *argp1 = 0 ;
43028 int res1 = 0 ;
43029 bool temp2 = false ;
43030 PyObject * obj0 = 0 ;
43031 PyObject * obj1 = 0 ;
43032 char * kwnames[] = {
43033 (char *) "self",(char *) "str", NULL
43034 };
43035
43036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43038 if (!SWIG_IsOK(res1)) {
43039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43040 }
43041 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43042 {
43043 arg2 = wxString_in_helper(obj1);
43044 if (arg2 == NULL) SWIG_fail;
43045 temp2 = true;
43046 }
43047 {
43048 PyThreadState* __tstate = wxPyBeginAllowThreads();
43049 (arg1)->SetHelp((wxString const &)*arg2);
43050 wxPyEndAllowThreads(__tstate);
43051 if (PyErr_Occurred()) SWIG_fail;
43052 }
43053 resultobj = SWIG_Py_Void();
43054 {
43055 if (temp2)
43056 delete arg2;
43057 }
43058 return resultobj;
43059 fail:
43060 {
43061 if (temp2)
43062 delete arg2;
43063 }
43064 return NULL;
43065 }
43066
43067
43068 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43069 PyObject *resultobj = 0;
43070 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43071 wxString *result = 0 ;
43072 void *argp1 = 0 ;
43073 int res1 = 0 ;
43074 PyObject *swig_obj[1] ;
43075
43076 if (!args) SWIG_fail;
43077 swig_obj[0] = args;
43078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43079 if (!SWIG_IsOK(res1)) {
43080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43081 }
43082 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43083 {
43084 PyThreadState* __tstate = wxPyBeginAllowThreads();
43085 {
43086 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43087 result = (wxString *) &_result_ref;
43088 }
43089 wxPyEndAllowThreads(__tstate);
43090 if (PyErr_Occurred()) SWIG_fail;
43091 }
43092 {
43093 #if wxUSE_UNICODE
43094 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43095 #else
43096 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43097 #endif
43098 }
43099 return resultobj;
43100 fail:
43101 return NULL;
43102 }
43103
43104
43105 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43106 PyObject *resultobj = 0;
43107 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43108 wxAcceleratorEntry *result = 0 ;
43109 void *argp1 = 0 ;
43110 int res1 = 0 ;
43111 PyObject *swig_obj[1] ;
43112
43113 if (!args) SWIG_fail;
43114 swig_obj[0] = args;
43115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43116 if (!SWIG_IsOK(res1)) {
43117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43118 }
43119 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43120 {
43121 PyThreadState* __tstate = wxPyBeginAllowThreads();
43122 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43123 wxPyEndAllowThreads(__tstate);
43124 if (PyErr_Occurred()) SWIG_fail;
43125 }
43126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43127 return resultobj;
43128 fail:
43129 return NULL;
43130 }
43131
43132
43133 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43134 PyObject *resultobj = 0;
43135 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43136 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43137 void *argp1 = 0 ;
43138 int res1 = 0 ;
43139 void *argp2 = 0 ;
43140 int res2 = 0 ;
43141 PyObject * obj0 = 0 ;
43142 PyObject * obj1 = 0 ;
43143 char * kwnames[] = {
43144 (char *) "self",(char *) "accel", NULL
43145 };
43146
43147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43149 if (!SWIG_IsOK(res1)) {
43150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43151 }
43152 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43154 if (!SWIG_IsOK(res2)) {
43155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43156 }
43157 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43158 {
43159 PyThreadState* __tstate = wxPyBeginAllowThreads();
43160 (arg1)->SetAccel(arg2);
43161 wxPyEndAllowThreads(__tstate);
43162 if (PyErr_Occurred()) SWIG_fail;
43163 }
43164 resultobj = SWIG_Py_Void();
43165 return resultobj;
43166 fail:
43167 return NULL;
43168 }
43169
43170
43171 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43172 PyObject *resultobj = 0;
43173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43174 wxBitmap *arg2 = 0 ;
43175 void *argp1 = 0 ;
43176 int res1 = 0 ;
43177 void *argp2 = 0 ;
43178 int res2 = 0 ;
43179 PyObject * obj0 = 0 ;
43180 PyObject * obj1 = 0 ;
43181 char * kwnames[] = {
43182 (char *) "self",(char *) "bitmap", NULL
43183 };
43184
43185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43187 if (!SWIG_IsOK(res1)) {
43188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43189 }
43190 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43191 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43192 if (!SWIG_IsOK(res2)) {
43193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43194 }
43195 if (!argp2) {
43196 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43197 }
43198 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43199 {
43200 PyThreadState* __tstate = wxPyBeginAllowThreads();
43201 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43202 wxPyEndAllowThreads(__tstate);
43203 if (PyErr_Occurred()) SWIG_fail;
43204 }
43205 resultobj = SWIG_Py_Void();
43206 return resultobj;
43207 fail:
43208 return NULL;
43209 }
43210
43211
43212 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43213 PyObject *resultobj = 0;
43214 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43215 wxBitmap *result = 0 ;
43216 void *argp1 = 0 ;
43217 int res1 = 0 ;
43218 PyObject *swig_obj[1] ;
43219
43220 if (!args) SWIG_fail;
43221 swig_obj[0] = args;
43222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43223 if (!SWIG_IsOK(res1)) {
43224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43225 }
43226 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43227 {
43228 PyThreadState* __tstate = wxPyBeginAllowThreads();
43229 {
43230 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43231 result = (wxBitmap *) &_result_ref;
43232 }
43233 wxPyEndAllowThreads(__tstate);
43234 if (PyErr_Occurred()) SWIG_fail;
43235 }
43236 {
43237 wxBitmap* resultptr = new wxBitmap(*result);
43238 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43239 }
43240 return resultobj;
43241 fail:
43242 return NULL;
43243 }
43244
43245
43246 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43247 PyObject *resultobj = 0;
43248 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43249 wxFont *arg2 = 0 ;
43250 void *argp1 = 0 ;
43251 int res1 = 0 ;
43252 void *argp2 = 0 ;
43253 int res2 = 0 ;
43254 PyObject * obj0 = 0 ;
43255 PyObject * obj1 = 0 ;
43256 char * kwnames[] = {
43257 (char *) "self",(char *) "font", NULL
43258 };
43259
43260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43262 if (!SWIG_IsOK(res1)) {
43263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43264 }
43265 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43266 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43267 if (!SWIG_IsOK(res2)) {
43268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43269 }
43270 if (!argp2) {
43271 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43272 }
43273 arg2 = reinterpret_cast< wxFont * >(argp2);
43274 {
43275 PyThreadState* __tstate = wxPyBeginAllowThreads();
43276 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43277 wxPyEndAllowThreads(__tstate);
43278 if (PyErr_Occurred()) SWIG_fail;
43279 }
43280 resultobj = SWIG_Py_Void();
43281 return resultobj;
43282 fail:
43283 return NULL;
43284 }
43285
43286
43287 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43288 PyObject *resultobj = 0;
43289 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43290 wxFont result;
43291 void *argp1 = 0 ;
43292 int res1 = 0 ;
43293 PyObject *swig_obj[1] ;
43294
43295 if (!args) SWIG_fail;
43296 swig_obj[0] = args;
43297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43298 if (!SWIG_IsOK(res1)) {
43299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43300 }
43301 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43302 {
43303 PyThreadState* __tstate = wxPyBeginAllowThreads();
43304 result = wxMenuItem_GetFont(arg1);
43305 wxPyEndAllowThreads(__tstate);
43306 if (PyErr_Occurred()) SWIG_fail;
43307 }
43308 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43309 return resultobj;
43310 fail:
43311 return NULL;
43312 }
43313
43314
43315 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43316 PyObject *resultobj = 0;
43317 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43318 wxColour *arg2 = 0 ;
43319 void *argp1 = 0 ;
43320 int res1 = 0 ;
43321 wxColour temp2 ;
43322 PyObject * obj0 = 0 ;
43323 PyObject * obj1 = 0 ;
43324 char * kwnames[] = {
43325 (char *) "self",(char *) "colText", NULL
43326 };
43327
43328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43330 if (!SWIG_IsOK(res1)) {
43331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43332 }
43333 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43334 {
43335 arg2 = &temp2;
43336 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43337 }
43338 {
43339 PyThreadState* __tstate = wxPyBeginAllowThreads();
43340 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43341 wxPyEndAllowThreads(__tstate);
43342 if (PyErr_Occurred()) SWIG_fail;
43343 }
43344 resultobj = SWIG_Py_Void();
43345 return resultobj;
43346 fail:
43347 return NULL;
43348 }
43349
43350
43351 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43352 PyObject *resultobj = 0;
43353 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43354 wxColour result;
43355 void *argp1 = 0 ;
43356 int res1 = 0 ;
43357 PyObject *swig_obj[1] ;
43358
43359 if (!args) SWIG_fail;
43360 swig_obj[0] = args;
43361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43362 if (!SWIG_IsOK(res1)) {
43363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43364 }
43365 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43366 {
43367 PyThreadState* __tstate = wxPyBeginAllowThreads();
43368 result = wxMenuItem_GetTextColour(arg1);
43369 wxPyEndAllowThreads(__tstate);
43370 if (PyErr_Occurred()) SWIG_fail;
43371 }
43372 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43373 return resultobj;
43374 fail:
43375 return NULL;
43376 }
43377
43378
43379 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43380 PyObject *resultobj = 0;
43381 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43382 wxColour *arg2 = 0 ;
43383 void *argp1 = 0 ;
43384 int res1 = 0 ;
43385 wxColour temp2 ;
43386 PyObject * obj0 = 0 ;
43387 PyObject * obj1 = 0 ;
43388 char * kwnames[] = {
43389 (char *) "self",(char *) "colBack", NULL
43390 };
43391
43392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43394 if (!SWIG_IsOK(res1)) {
43395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43396 }
43397 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43398 {
43399 arg2 = &temp2;
43400 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43401 }
43402 {
43403 PyThreadState* __tstate = wxPyBeginAllowThreads();
43404 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43405 wxPyEndAllowThreads(__tstate);
43406 if (PyErr_Occurred()) SWIG_fail;
43407 }
43408 resultobj = SWIG_Py_Void();
43409 return resultobj;
43410 fail:
43411 return NULL;
43412 }
43413
43414
43415 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43416 PyObject *resultobj = 0;
43417 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43418 wxColour result;
43419 void *argp1 = 0 ;
43420 int res1 = 0 ;
43421 PyObject *swig_obj[1] ;
43422
43423 if (!args) SWIG_fail;
43424 swig_obj[0] = args;
43425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43426 if (!SWIG_IsOK(res1)) {
43427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43428 }
43429 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43430 {
43431 PyThreadState* __tstate = wxPyBeginAllowThreads();
43432 result = wxMenuItem_GetBackgroundColour(arg1);
43433 wxPyEndAllowThreads(__tstate);
43434 if (PyErr_Occurred()) SWIG_fail;
43435 }
43436 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43437 return resultobj;
43438 fail:
43439 return NULL;
43440 }
43441
43442
43443 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43444 PyObject *resultobj = 0;
43445 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43446 wxBitmap *arg2 = 0 ;
43447 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43448 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43449 void *argp1 = 0 ;
43450 int res1 = 0 ;
43451 void *argp2 = 0 ;
43452 int res2 = 0 ;
43453 void *argp3 = 0 ;
43454 int res3 = 0 ;
43455 PyObject * obj0 = 0 ;
43456 PyObject * obj1 = 0 ;
43457 PyObject * obj2 = 0 ;
43458 char * kwnames[] = {
43459 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43460 };
43461
43462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43464 if (!SWIG_IsOK(res1)) {
43465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43466 }
43467 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43468 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43469 if (!SWIG_IsOK(res2)) {
43470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43471 }
43472 if (!argp2) {
43473 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43474 }
43475 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43476 if (obj2) {
43477 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43478 if (!SWIG_IsOK(res3)) {
43479 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43480 }
43481 if (!argp3) {
43482 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43483 }
43484 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43485 }
43486 {
43487 PyThreadState* __tstate = wxPyBeginAllowThreads();
43488 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43489 wxPyEndAllowThreads(__tstate);
43490 if (PyErr_Occurred()) SWIG_fail;
43491 }
43492 resultobj = SWIG_Py_Void();
43493 return resultobj;
43494 fail:
43495 return NULL;
43496 }
43497
43498
43499 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43500 PyObject *resultobj = 0;
43501 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43502 wxBitmap *arg2 = 0 ;
43503 void *argp1 = 0 ;
43504 int res1 = 0 ;
43505 void *argp2 = 0 ;
43506 int res2 = 0 ;
43507 PyObject * obj0 = 0 ;
43508 PyObject * obj1 = 0 ;
43509 char * kwnames[] = {
43510 (char *) "self",(char *) "bmpDisabled", NULL
43511 };
43512
43513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43515 if (!SWIG_IsOK(res1)) {
43516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43517 }
43518 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43519 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43520 if (!SWIG_IsOK(res2)) {
43521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43522 }
43523 if (!argp2) {
43524 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43525 }
43526 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43527 {
43528 PyThreadState* __tstate = wxPyBeginAllowThreads();
43529 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43530 wxPyEndAllowThreads(__tstate);
43531 if (PyErr_Occurred()) SWIG_fail;
43532 }
43533 resultobj = SWIG_Py_Void();
43534 return resultobj;
43535 fail:
43536 return NULL;
43537 }
43538
43539
43540 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43541 PyObject *resultobj = 0;
43542 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43543 wxBitmap *result = 0 ;
43544 void *argp1 = 0 ;
43545 int res1 = 0 ;
43546 PyObject *swig_obj[1] ;
43547
43548 if (!args) SWIG_fail;
43549 swig_obj[0] = args;
43550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43551 if (!SWIG_IsOK(res1)) {
43552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43553 }
43554 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43555 {
43556 PyThreadState* __tstate = wxPyBeginAllowThreads();
43557 {
43558 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43559 result = (wxBitmap *) &_result_ref;
43560 }
43561 wxPyEndAllowThreads(__tstate);
43562 if (PyErr_Occurred()) SWIG_fail;
43563 }
43564 {
43565 wxBitmap* resultptr = new wxBitmap(*result);
43566 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43567 }
43568 return resultobj;
43569 fail:
43570 return NULL;
43571 }
43572
43573
43574 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43575 PyObject *resultobj = 0;
43576 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43577 int arg2 ;
43578 void *argp1 = 0 ;
43579 int res1 = 0 ;
43580 int val2 ;
43581 int ecode2 = 0 ;
43582 PyObject * obj0 = 0 ;
43583 PyObject * obj1 = 0 ;
43584 char * kwnames[] = {
43585 (char *) "self",(char *) "nWidth", NULL
43586 };
43587
43588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43590 if (!SWIG_IsOK(res1)) {
43591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43592 }
43593 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43594 ecode2 = SWIG_AsVal_int(obj1, &val2);
43595 if (!SWIG_IsOK(ecode2)) {
43596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43597 }
43598 arg2 = static_cast< int >(val2);
43599 {
43600 PyThreadState* __tstate = wxPyBeginAllowThreads();
43601 wxMenuItem_SetMarginWidth(arg1,arg2);
43602 wxPyEndAllowThreads(__tstate);
43603 if (PyErr_Occurred()) SWIG_fail;
43604 }
43605 resultobj = SWIG_Py_Void();
43606 return resultobj;
43607 fail:
43608 return NULL;
43609 }
43610
43611
43612 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43613 PyObject *resultobj = 0;
43614 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43615 int result;
43616 void *argp1 = 0 ;
43617 int res1 = 0 ;
43618 PyObject *swig_obj[1] ;
43619
43620 if (!args) SWIG_fail;
43621 swig_obj[0] = args;
43622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43623 if (!SWIG_IsOK(res1)) {
43624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43625 }
43626 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43627 {
43628 PyThreadState* __tstate = wxPyBeginAllowThreads();
43629 result = (int)wxMenuItem_GetMarginWidth(arg1);
43630 wxPyEndAllowThreads(__tstate);
43631 if (PyErr_Occurred()) SWIG_fail;
43632 }
43633 resultobj = SWIG_From_int(static_cast< int >(result));
43634 return resultobj;
43635 fail:
43636 return NULL;
43637 }
43638
43639
43640 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43641 PyObject *resultobj = 0;
43642 int result;
43643
43644 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43645 {
43646 PyThreadState* __tstate = wxPyBeginAllowThreads();
43647 result = (int)wxMenuItem_GetDefaultMarginWidth();
43648 wxPyEndAllowThreads(__tstate);
43649 if (PyErr_Occurred()) SWIG_fail;
43650 }
43651 resultobj = SWIG_From_int(static_cast< int >(result));
43652 return resultobj;
43653 fail:
43654 return NULL;
43655 }
43656
43657
43658 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43659 PyObject *resultobj = 0;
43660 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43661 bool result;
43662 void *argp1 = 0 ;
43663 int res1 = 0 ;
43664 PyObject *swig_obj[1] ;
43665
43666 if (!args) SWIG_fail;
43667 swig_obj[0] = args;
43668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43669 if (!SWIG_IsOK(res1)) {
43670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43671 }
43672 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43673 {
43674 PyThreadState* __tstate = wxPyBeginAllowThreads();
43675 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43676 wxPyEndAllowThreads(__tstate);
43677 if (PyErr_Occurred()) SWIG_fail;
43678 }
43679 {
43680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43681 }
43682 return resultobj;
43683 fail:
43684 return NULL;
43685 }
43686
43687
43688 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43689 PyObject *resultobj = 0;
43690 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43691 bool arg2 = (bool) true ;
43692 void *argp1 = 0 ;
43693 int res1 = 0 ;
43694 bool val2 ;
43695 int ecode2 = 0 ;
43696 PyObject * obj0 = 0 ;
43697 PyObject * obj1 = 0 ;
43698 char * kwnames[] = {
43699 (char *) "self",(char *) "ownerDrawn", NULL
43700 };
43701
43702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43704 if (!SWIG_IsOK(res1)) {
43705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43706 }
43707 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43708 if (obj1) {
43709 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43710 if (!SWIG_IsOK(ecode2)) {
43711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43712 }
43713 arg2 = static_cast< bool >(val2);
43714 }
43715 {
43716 PyThreadState* __tstate = wxPyBeginAllowThreads();
43717 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43718 wxPyEndAllowThreads(__tstate);
43719 if (PyErr_Occurred()) SWIG_fail;
43720 }
43721 resultobj = SWIG_Py_Void();
43722 return resultobj;
43723 fail:
43724 return NULL;
43725 }
43726
43727
43728 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43729 PyObject *resultobj = 0;
43730 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43731 void *argp1 = 0 ;
43732 int res1 = 0 ;
43733 PyObject *swig_obj[1] ;
43734
43735 if (!args) SWIG_fail;
43736 swig_obj[0] = args;
43737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43738 if (!SWIG_IsOK(res1)) {
43739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43740 }
43741 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43742 {
43743 PyThreadState* __tstate = wxPyBeginAllowThreads();
43744 wxMenuItem_ResetOwnerDrawn(arg1);
43745 wxPyEndAllowThreads(__tstate);
43746 if (PyErr_Occurred()) SWIG_fail;
43747 }
43748 resultobj = SWIG_Py_Void();
43749 return resultobj;
43750 fail:
43751 return NULL;
43752 }
43753
43754
43755 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43756 PyObject *obj;
43757 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43758 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43759 return SWIG_Py_Void();
43760 }
43761
43762 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43763 return SWIG_Python_InitShadowInstance(args);
43764 }
43765
43766 SWIGINTERN int ControlNameStr_set(PyObject *) {
43767 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43768 return 1;
43769 }
43770
43771
43772 SWIGINTERN PyObject *ControlNameStr_get(void) {
43773 PyObject *pyobj = 0;
43774
43775 {
43776 #if wxUSE_UNICODE
43777 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43778 #else
43779 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43780 #endif
43781 }
43782 return pyobj;
43783 }
43784
43785
43786 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43787 PyObject *resultobj = 0;
43788 wxWindow *arg1 = (wxWindow *) 0 ;
43789 int arg2 = (int) -1 ;
43790 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43791 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43792 wxSize const &arg4_defvalue = wxDefaultSize ;
43793 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43794 long arg5 = (long) 0 ;
43795 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43796 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43797 wxString const &arg7_defvalue = wxPyControlNameStr ;
43798 wxString *arg7 = (wxString *) &arg7_defvalue ;
43799 wxControl *result = 0 ;
43800 void *argp1 = 0 ;
43801 int res1 = 0 ;
43802 int val2 ;
43803 int ecode2 = 0 ;
43804 wxPoint temp3 ;
43805 wxSize temp4 ;
43806 long val5 ;
43807 int ecode5 = 0 ;
43808 void *argp6 = 0 ;
43809 int res6 = 0 ;
43810 bool temp7 = false ;
43811 PyObject * obj0 = 0 ;
43812 PyObject * obj1 = 0 ;
43813 PyObject * obj2 = 0 ;
43814 PyObject * obj3 = 0 ;
43815 PyObject * obj4 = 0 ;
43816 PyObject * obj5 = 0 ;
43817 PyObject * obj6 = 0 ;
43818 char * kwnames[] = {
43819 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43820 };
43821
43822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43824 if (!SWIG_IsOK(res1)) {
43825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43826 }
43827 arg1 = reinterpret_cast< wxWindow * >(argp1);
43828 if (obj1) {
43829 ecode2 = SWIG_AsVal_int(obj1, &val2);
43830 if (!SWIG_IsOK(ecode2)) {
43831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43832 }
43833 arg2 = static_cast< int >(val2);
43834 }
43835 if (obj2) {
43836 {
43837 arg3 = &temp3;
43838 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43839 }
43840 }
43841 if (obj3) {
43842 {
43843 arg4 = &temp4;
43844 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43845 }
43846 }
43847 if (obj4) {
43848 ecode5 = SWIG_AsVal_long(obj4, &val5);
43849 if (!SWIG_IsOK(ecode5)) {
43850 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43851 }
43852 arg5 = static_cast< long >(val5);
43853 }
43854 if (obj5) {
43855 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43856 if (!SWIG_IsOK(res6)) {
43857 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43858 }
43859 if (!argp6) {
43860 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43861 }
43862 arg6 = reinterpret_cast< wxValidator * >(argp6);
43863 }
43864 if (obj6) {
43865 {
43866 arg7 = wxString_in_helper(obj6);
43867 if (arg7 == NULL) SWIG_fail;
43868 temp7 = true;
43869 }
43870 }
43871 {
43872 if (!wxPyCheckForApp()) SWIG_fail;
43873 PyThreadState* __tstate = wxPyBeginAllowThreads();
43874 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43875 wxPyEndAllowThreads(__tstate);
43876 if (PyErr_Occurred()) SWIG_fail;
43877 }
43878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43879 {
43880 if (temp7)
43881 delete arg7;
43882 }
43883 return resultobj;
43884 fail:
43885 {
43886 if (temp7)
43887 delete arg7;
43888 }
43889 return NULL;
43890 }
43891
43892
43893 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43894 PyObject *resultobj = 0;
43895 wxControl *result = 0 ;
43896
43897 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43898 {
43899 if (!wxPyCheckForApp()) SWIG_fail;
43900 PyThreadState* __tstate = wxPyBeginAllowThreads();
43901 result = (wxControl *)new wxControl();
43902 wxPyEndAllowThreads(__tstate);
43903 if (PyErr_Occurred()) SWIG_fail;
43904 }
43905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43906 return resultobj;
43907 fail:
43908 return NULL;
43909 }
43910
43911
43912 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43913 PyObject *resultobj = 0;
43914 wxControl *arg1 = (wxControl *) 0 ;
43915 wxWindow *arg2 = (wxWindow *) 0 ;
43916 int arg3 = (int) -1 ;
43917 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43918 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43919 wxSize const &arg5_defvalue = wxDefaultSize ;
43920 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43921 long arg6 = (long) 0 ;
43922 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43923 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43924 wxString const &arg8_defvalue = wxPyControlNameStr ;
43925 wxString *arg8 = (wxString *) &arg8_defvalue ;
43926 bool result;
43927 void *argp1 = 0 ;
43928 int res1 = 0 ;
43929 void *argp2 = 0 ;
43930 int res2 = 0 ;
43931 int val3 ;
43932 int ecode3 = 0 ;
43933 wxPoint temp4 ;
43934 wxSize temp5 ;
43935 long val6 ;
43936 int ecode6 = 0 ;
43937 void *argp7 = 0 ;
43938 int res7 = 0 ;
43939 bool temp8 = false ;
43940 PyObject * obj0 = 0 ;
43941 PyObject * obj1 = 0 ;
43942 PyObject * obj2 = 0 ;
43943 PyObject * obj3 = 0 ;
43944 PyObject * obj4 = 0 ;
43945 PyObject * obj5 = 0 ;
43946 PyObject * obj6 = 0 ;
43947 PyObject * obj7 = 0 ;
43948 char * kwnames[] = {
43949 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43950 };
43951
43952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43954 if (!SWIG_IsOK(res1)) {
43955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43956 }
43957 arg1 = reinterpret_cast< wxControl * >(argp1);
43958 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43959 if (!SWIG_IsOK(res2)) {
43960 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43961 }
43962 arg2 = reinterpret_cast< wxWindow * >(argp2);
43963 if (obj2) {
43964 ecode3 = SWIG_AsVal_int(obj2, &val3);
43965 if (!SWIG_IsOK(ecode3)) {
43966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43967 }
43968 arg3 = static_cast< int >(val3);
43969 }
43970 if (obj3) {
43971 {
43972 arg4 = &temp4;
43973 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43974 }
43975 }
43976 if (obj4) {
43977 {
43978 arg5 = &temp5;
43979 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43980 }
43981 }
43982 if (obj5) {
43983 ecode6 = SWIG_AsVal_long(obj5, &val6);
43984 if (!SWIG_IsOK(ecode6)) {
43985 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43986 }
43987 arg6 = static_cast< long >(val6);
43988 }
43989 if (obj6) {
43990 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43991 if (!SWIG_IsOK(res7)) {
43992 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43993 }
43994 if (!argp7) {
43995 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43996 }
43997 arg7 = reinterpret_cast< wxValidator * >(argp7);
43998 }
43999 if (obj7) {
44000 {
44001 arg8 = wxString_in_helper(obj7);
44002 if (arg8 == NULL) SWIG_fail;
44003 temp8 = true;
44004 }
44005 }
44006 {
44007 PyThreadState* __tstate = wxPyBeginAllowThreads();
44008 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44009 wxPyEndAllowThreads(__tstate);
44010 if (PyErr_Occurred()) SWIG_fail;
44011 }
44012 {
44013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44014 }
44015 {
44016 if (temp8)
44017 delete arg8;
44018 }
44019 return resultobj;
44020 fail:
44021 {
44022 if (temp8)
44023 delete arg8;
44024 }
44025 return NULL;
44026 }
44027
44028
44029 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44030 PyObject *resultobj = 0;
44031 wxControl *arg1 = (wxControl *) 0 ;
44032 int result;
44033 void *argp1 = 0 ;
44034 int res1 = 0 ;
44035 PyObject *swig_obj[1] ;
44036
44037 if (!args) SWIG_fail;
44038 swig_obj[0] = args;
44039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44040 if (!SWIG_IsOK(res1)) {
44041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44042 }
44043 arg1 = reinterpret_cast< wxControl * >(argp1);
44044 {
44045 PyThreadState* __tstate = wxPyBeginAllowThreads();
44046 result = (int)((wxControl const *)arg1)->GetAlignment();
44047 wxPyEndAllowThreads(__tstate);
44048 if (PyErr_Occurred()) SWIG_fail;
44049 }
44050 resultobj = SWIG_From_int(static_cast< int >(result));
44051 return resultobj;
44052 fail:
44053 return NULL;
44054 }
44055
44056
44057 SWIGINTERN PyObject *_wrap_Control_GetLabelText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
44058 PyObject *resultobj = 0;
44059 wxString *arg1 = 0 ;
44060 wxString result;
44061 bool temp1 = false ;
44062
44063 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
44064 {
44065 arg1 = wxString_in_helper(swig_obj[0]);
44066 if (arg1 == NULL) SWIG_fail;
44067 temp1 = true;
44068 }
44069 {
44070 PyThreadState* __tstate = wxPyBeginAllowThreads();
44071 result = wxControl::GetLabelText((wxString const &)*arg1);
44072 wxPyEndAllowThreads(__tstate);
44073 if (PyErr_Occurred()) SWIG_fail;
44074 }
44075 {
44076 #if wxUSE_UNICODE
44077 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44078 #else
44079 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44080 #endif
44081 }
44082 {
44083 if (temp1)
44084 delete arg1;
44085 }
44086 return resultobj;
44087 fail:
44088 {
44089 if (temp1)
44090 delete arg1;
44091 }
44092 return NULL;
44093 }
44094
44095
44096 SWIGINTERN PyObject *_wrap_Control_GetLabelText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
44097 PyObject *resultobj = 0;
44098 wxControl *arg1 = (wxControl *) 0 ;
44099 wxString result;
44100 void *argp1 = 0 ;
44101 int res1 = 0 ;
44102
44103 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
44104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44105 if (!SWIG_IsOK(res1)) {
44106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44107 }
44108 arg1 = reinterpret_cast< wxControl * >(argp1);
44109 {
44110 PyThreadState* __tstate = wxPyBeginAllowThreads();
44111 result = ((wxControl const *)arg1)->GetLabelText();
44112 wxPyEndAllowThreads(__tstate);
44113 if (PyErr_Occurred()) SWIG_fail;
44114 }
44115 {
44116 #if wxUSE_UNICODE
44117 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44118 #else
44119 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44120 #endif
44121 }
44122 return resultobj;
44123 fail:
44124 return NULL;
44125 }
44126
44127
44128 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *self, PyObject *args) {
44129 int argc;
44130 PyObject *argv[2];
44131
44132 if (!(argc = SWIG_Python_UnpackTuple(args,"Control_GetLabelText",0,1,argv))) SWIG_fail;
44133 --argc;
44134 if (argc == 1) {
44135 int _v = 0;
44136 {
44137 {
44138 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
44139 }
44140 }
44141 if (!_v) goto check_1;
44142 return _wrap_Control_GetLabelText__SWIG_0(self, argc, argv);
44143 }
44144 check_1:
44145
44146 if (argc == 1) {
44147 return _wrap_Control_GetLabelText__SWIG_1(self, argc, argv);
44148 }
44149
44150 fail:
44151 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Control_GetLabelText'");
44152 return NULL;
44153 }
44154
44155
44156 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44157 PyObject *resultobj = 0;
44158 wxControl *arg1 = (wxControl *) 0 ;
44159 wxCommandEvent *arg2 = 0 ;
44160 void *argp1 = 0 ;
44161 int res1 = 0 ;
44162 void *argp2 = 0 ;
44163 int res2 = 0 ;
44164 PyObject * obj0 = 0 ;
44165 PyObject * obj1 = 0 ;
44166 char * kwnames[] = {
44167 (char *) "self",(char *) "event", NULL
44168 };
44169
44170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44172 if (!SWIG_IsOK(res1)) {
44173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44174 }
44175 arg1 = reinterpret_cast< wxControl * >(argp1);
44176 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44177 if (!SWIG_IsOK(res2)) {
44178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44179 }
44180 if (!argp2) {
44181 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44182 }
44183 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44184 {
44185 PyThreadState* __tstate = wxPyBeginAllowThreads();
44186 (arg1)->Command(*arg2);
44187 wxPyEndAllowThreads(__tstate);
44188 if (PyErr_Occurred()) SWIG_fail;
44189 }
44190 resultobj = SWIG_Py_Void();
44191 return resultobj;
44192 fail:
44193 return NULL;
44194 }
44195
44196
44197 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44198 PyObject *resultobj = 0;
44199 wxControl *arg1 = (wxControl *) 0 ;
44200 wxString result;
44201 void *argp1 = 0 ;
44202 int res1 = 0 ;
44203 PyObject *swig_obj[1] ;
44204
44205 if (!args) SWIG_fail;
44206 swig_obj[0] = args;
44207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44208 if (!SWIG_IsOK(res1)) {
44209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44210 }
44211 arg1 = reinterpret_cast< wxControl * >(argp1);
44212 {
44213 PyThreadState* __tstate = wxPyBeginAllowThreads();
44214 result = (arg1)->GetLabel();
44215 wxPyEndAllowThreads(__tstate);
44216 if (PyErr_Occurred()) SWIG_fail;
44217 }
44218 {
44219 #if wxUSE_UNICODE
44220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44221 #else
44222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44223 #endif
44224 }
44225 return resultobj;
44226 fail:
44227 return NULL;
44228 }
44229
44230
44231 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44232 PyObject *resultobj = 0;
44233 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44234 SwigValueWrapper<wxVisualAttributes > result;
44235 int val1 ;
44236 int ecode1 = 0 ;
44237 PyObject * obj0 = 0 ;
44238 char * kwnames[] = {
44239 (char *) "variant", NULL
44240 };
44241
44242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44243 if (obj0) {
44244 ecode1 = SWIG_AsVal_int(obj0, &val1);
44245 if (!SWIG_IsOK(ecode1)) {
44246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44247 }
44248 arg1 = static_cast< wxWindowVariant >(val1);
44249 }
44250 {
44251 if (!wxPyCheckForApp()) SWIG_fail;
44252 PyThreadState* __tstate = wxPyBeginAllowThreads();
44253 result = wxControl::GetClassDefaultAttributes(arg1);
44254 wxPyEndAllowThreads(__tstate);
44255 if (PyErr_Occurred()) SWIG_fail;
44256 }
44257 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44258 return resultobj;
44259 fail:
44260 return NULL;
44261 }
44262
44263
44264 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44265 PyObject *obj;
44266 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44267 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44268 return SWIG_Py_Void();
44269 }
44270
44271 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44272 return SWIG_Python_InitShadowInstance(args);
44273 }
44274
44275 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44276 PyObject *resultobj = 0;
44277 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44278 wxString *arg2 = 0 ;
44279 PyObject *arg3 = (PyObject *) NULL ;
44280 int result;
44281 void *argp1 = 0 ;
44282 int res1 = 0 ;
44283 bool temp2 = false ;
44284 PyObject * obj0 = 0 ;
44285 PyObject * obj1 = 0 ;
44286 PyObject * obj2 = 0 ;
44287 char * kwnames[] = {
44288 (char *) "self",(char *) "item",(char *) "clientData", NULL
44289 };
44290
44291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44293 if (!SWIG_IsOK(res1)) {
44294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44295 }
44296 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44297 {
44298 arg2 = wxString_in_helper(obj1);
44299 if (arg2 == NULL) SWIG_fail;
44300 temp2 = true;
44301 }
44302 if (obj2) {
44303 arg3 = obj2;
44304 }
44305 {
44306 PyThreadState* __tstate = wxPyBeginAllowThreads();
44307 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44308 wxPyEndAllowThreads(__tstate);
44309 if (PyErr_Occurred()) SWIG_fail;
44310 }
44311 resultobj = SWIG_From_int(static_cast< int >(result));
44312 {
44313 if (temp2)
44314 delete arg2;
44315 }
44316 return resultobj;
44317 fail:
44318 {
44319 if (temp2)
44320 delete arg2;
44321 }
44322 return NULL;
44323 }
44324
44325
44326 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44327 PyObject *resultobj = 0;
44328 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44329 wxArrayString *arg2 = 0 ;
44330 void *argp1 = 0 ;
44331 int res1 = 0 ;
44332 bool temp2 = false ;
44333 PyObject * obj0 = 0 ;
44334 PyObject * obj1 = 0 ;
44335 char * kwnames[] = {
44336 (char *) "self",(char *) "strings", NULL
44337 };
44338
44339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44341 if (!SWIG_IsOK(res1)) {
44342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44343 }
44344 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44345 {
44346 if (! PySequence_Check(obj1)) {
44347 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44348 SWIG_fail;
44349 }
44350 arg2 = new wxArrayString;
44351 temp2 = true;
44352 int i, len=PySequence_Length(obj1);
44353 for (i=0; i<len; i++) {
44354 PyObject* item = PySequence_GetItem(obj1, i);
44355 wxString* s = wxString_in_helper(item);
44356 if (PyErr_Occurred()) SWIG_fail;
44357 arg2->Add(*s);
44358 delete s;
44359 Py_DECREF(item);
44360 }
44361 }
44362 {
44363 PyThreadState* __tstate = wxPyBeginAllowThreads();
44364 (arg1)->Append((wxArrayString const &)*arg2);
44365 wxPyEndAllowThreads(__tstate);
44366 if (PyErr_Occurred()) SWIG_fail;
44367 }
44368 resultobj = SWIG_Py_Void();
44369 {
44370 if (temp2) delete arg2;
44371 }
44372 return resultobj;
44373 fail:
44374 {
44375 if (temp2) delete arg2;
44376 }
44377 return NULL;
44378 }
44379
44380
44381 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44382 PyObject *resultobj = 0;
44383 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44384 wxString *arg2 = 0 ;
44385 unsigned int arg3 ;
44386 PyObject *arg4 = (PyObject *) NULL ;
44387 int result;
44388 void *argp1 = 0 ;
44389 int res1 = 0 ;
44390 bool temp2 = false ;
44391 unsigned int val3 ;
44392 int ecode3 = 0 ;
44393 PyObject * obj0 = 0 ;
44394 PyObject * obj1 = 0 ;
44395 PyObject * obj2 = 0 ;
44396 PyObject * obj3 = 0 ;
44397 char * kwnames[] = {
44398 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44399 };
44400
44401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44403 if (!SWIG_IsOK(res1)) {
44404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44405 }
44406 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44407 {
44408 arg2 = wxString_in_helper(obj1);
44409 if (arg2 == NULL) SWIG_fail;
44410 temp2 = true;
44411 }
44412 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44413 if (!SWIG_IsOK(ecode3)) {
44414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44415 }
44416 arg3 = static_cast< unsigned int >(val3);
44417 if (obj3) {
44418 arg4 = obj3;
44419 }
44420 {
44421 PyThreadState* __tstate = wxPyBeginAllowThreads();
44422 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44423 wxPyEndAllowThreads(__tstate);
44424 if (PyErr_Occurred()) SWIG_fail;
44425 }
44426 resultobj = SWIG_From_int(static_cast< int >(result));
44427 {
44428 if (temp2)
44429 delete arg2;
44430 }
44431 return resultobj;
44432 fail:
44433 {
44434 if (temp2)
44435 delete arg2;
44436 }
44437 return NULL;
44438 }
44439
44440
44441 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44442 PyObject *resultobj = 0;
44443 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44444 void *argp1 = 0 ;
44445 int res1 = 0 ;
44446 PyObject *swig_obj[1] ;
44447
44448 if (!args) SWIG_fail;
44449 swig_obj[0] = args;
44450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44451 if (!SWIG_IsOK(res1)) {
44452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44453 }
44454 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44455 {
44456 PyThreadState* __tstate = wxPyBeginAllowThreads();
44457 (arg1)->Clear();
44458 wxPyEndAllowThreads(__tstate);
44459 if (PyErr_Occurred()) SWIG_fail;
44460 }
44461 resultobj = SWIG_Py_Void();
44462 return resultobj;
44463 fail:
44464 return NULL;
44465 }
44466
44467
44468 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44469 PyObject *resultobj = 0;
44470 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44471 unsigned int arg2 ;
44472 void *argp1 = 0 ;
44473 int res1 = 0 ;
44474 unsigned int val2 ;
44475 int ecode2 = 0 ;
44476 PyObject * obj0 = 0 ;
44477 PyObject * obj1 = 0 ;
44478 char * kwnames[] = {
44479 (char *) "self",(char *) "n", NULL
44480 };
44481
44482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44484 if (!SWIG_IsOK(res1)) {
44485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44486 }
44487 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44488 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44489 if (!SWIG_IsOK(ecode2)) {
44490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44491 }
44492 arg2 = static_cast< unsigned int >(val2);
44493 {
44494 PyThreadState* __tstate = wxPyBeginAllowThreads();
44495 (arg1)->Delete(arg2);
44496 wxPyEndAllowThreads(__tstate);
44497 if (PyErr_Occurred()) SWIG_fail;
44498 }
44499 resultobj = SWIG_Py_Void();
44500 return resultobj;
44501 fail:
44502 return NULL;
44503 }
44504
44505
44506 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44507 PyObject *resultobj = 0;
44508 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44509 unsigned int arg2 ;
44510 PyObject *result = 0 ;
44511 void *argp1 = 0 ;
44512 int res1 = 0 ;
44513 unsigned int val2 ;
44514 int ecode2 = 0 ;
44515 PyObject * obj0 = 0 ;
44516 PyObject * obj1 = 0 ;
44517 char * kwnames[] = {
44518 (char *) "self",(char *) "n", NULL
44519 };
44520
44521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44523 if (!SWIG_IsOK(res1)) {
44524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44525 }
44526 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44527 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44528 if (!SWIG_IsOK(ecode2)) {
44529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44530 }
44531 arg2 = static_cast< unsigned int >(val2);
44532 {
44533 PyThreadState* __tstate = wxPyBeginAllowThreads();
44534 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44535 wxPyEndAllowThreads(__tstate);
44536 if (PyErr_Occurred()) SWIG_fail;
44537 }
44538 resultobj = result;
44539 return resultobj;
44540 fail:
44541 return NULL;
44542 }
44543
44544
44545 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44546 PyObject *resultobj = 0;
44547 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44548 unsigned int arg2 ;
44549 PyObject *arg3 = (PyObject *) 0 ;
44550 void *argp1 = 0 ;
44551 int res1 = 0 ;
44552 unsigned int val2 ;
44553 int ecode2 = 0 ;
44554 PyObject * obj0 = 0 ;
44555 PyObject * obj1 = 0 ;
44556 PyObject * obj2 = 0 ;
44557 char * kwnames[] = {
44558 (char *) "self",(char *) "n",(char *) "clientData", NULL
44559 };
44560
44561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44563 if (!SWIG_IsOK(res1)) {
44564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44565 }
44566 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44567 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44568 if (!SWIG_IsOK(ecode2)) {
44569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44570 }
44571 arg2 = static_cast< unsigned int >(val2);
44572 arg3 = obj2;
44573 {
44574 PyThreadState* __tstate = wxPyBeginAllowThreads();
44575 wxItemContainer_SetClientData(arg1,arg2,arg3);
44576 wxPyEndAllowThreads(__tstate);
44577 if (PyErr_Occurred()) SWIG_fail;
44578 }
44579 resultobj = SWIG_Py_Void();
44580 return resultobj;
44581 fail:
44582 return NULL;
44583 }
44584
44585
44586 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44587 PyObject *resultobj = 0;
44588 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44589 unsigned int result;
44590 void *argp1 = 0 ;
44591 int res1 = 0 ;
44592 PyObject *swig_obj[1] ;
44593
44594 if (!args) SWIG_fail;
44595 swig_obj[0] = args;
44596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44597 if (!SWIG_IsOK(res1)) {
44598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44599 }
44600 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44601 {
44602 PyThreadState* __tstate = wxPyBeginAllowThreads();
44603 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44604 wxPyEndAllowThreads(__tstate);
44605 if (PyErr_Occurred()) SWIG_fail;
44606 }
44607 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44608 return resultobj;
44609 fail:
44610 return NULL;
44611 }
44612
44613
44614 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44615 PyObject *resultobj = 0;
44616 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44617 bool result;
44618 void *argp1 = 0 ;
44619 int res1 = 0 ;
44620 PyObject *swig_obj[1] ;
44621
44622 if (!args) SWIG_fail;
44623 swig_obj[0] = args;
44624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44625 if (!SWIG_IsOK(res1)) {
44626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44627 }
44628 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44629 {
44630 PyThreadState* __tstate = wxPyBeginAllowThreads();
44631 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44632 wxPyEndAllowThreads(__tstate);
44633 if (PyErr_Occurred()) SWIG_fail;
44634 }
44635 {
44636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44637 }
44638 return resultobj;
44639 fail:
44640 return NULL;
44641 }
44642
44643
44644 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44645 PyObject *resultobj = 0;
44646 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44647 unsigned int arg2 ;
44648 wxString result;
44649 void *argp1 = 0 ;
44650 int res1 = 0 ;
44651 unsigned int val2 ;
44652 int ecode2 = 0 ;
44653 PyObject * obj0 = 0 ;
44654 PyObject * obj1 = 0 ;
44655 char * kwnames[] = {
44656 (char *) "self",(char *) "n", NULL
44657 };
44658
44659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44661 if (!SWIG_IsOK(res1)) {
44662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44663 }
44664 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44665 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44666 if (!SWIG_IsOK(ecode2)) {
44667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44668 }
44669 arg2 = static_cast< unsigned int >(val2);
44670 {
44671 PyThreadState* __tstate = wxPyBeginAllowThreads();
44672 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44673 wxPyEndAllowThreads(__tstate);
44674 if (PyErr_Occurred()) SWIG_fail;
44675 }
44676 {
44677 #if wxUSE_UNICODE
44678 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44679 #else
44680 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44681 #endif
44682 }
44683 return resultobj;
44684 fail:
44685 return NULL;
44686 }
44687
44688
44689 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44690 PyObject *resultobj = 0;
44691 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44692 wxArrayString result;
44693 void *argp1 = 0 ;
44694 int res1 = 0 ;
44695 PyObject *swig_obj[1] ;
44696
44697 if (!args) SWIG_fail;
44698 swig_obj[0] = args;
44699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44700 if (!SWIG_IsOK(res1)) {
44701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44702 }
44703 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44704 {
44705 PyThreadState* __tstate = wxPyBeginAllowThreads();
44706 result = ((wxItemContainer const *)arg1)->GetStrings();
44707 wxPyEndAllowThreads(__tstate);
44708 if (PyErr_Occurred()) SWIG_fail;
44709 }
44710 {
44711 resultobj = wxArrayString2PyList_helper(result);
44712 }
44713 return resultobj;
44714 fail:
44715 return NULL;
44716 }
44717
44718
44719 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44720 PyObject *resultobj = 0;
44721 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44722 unsigned int arg2 ;
44723 wxString *arg3 = 0 ;
44724 void *argp1 = 0 ;
44725 int res1 = 0 ;
44726 unsigned int val2 ;
44727 int ecode2 = 0 ;
44728 bool temp3 = false ;
44729 PyObject * obj0 = 0 ;
44730 PyObject * obj1 = 0 ;
44731 PyObject * obj2 = 0 ;
44732 char * kwnames[] = {
44733 (char *) "self",(char *) "n",(char *) "s", NULL
44734 };
44735
44736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44738 if (!SWIG_IsOK(res1)) {
44739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44740 }
44741 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44742 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44743 if (!SWIG_IsOK(ecode2)) {
44744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44745 }
44746 arg2 = static_cast< unsigned int >(val2);
44747 {
44748 arg3 = wxString_in_helper(obj2);
44749 if (arg3 == NULL) SWIG_fail;
44750 temp3 = true;
44751 }
44752 {
44753 PyThreadState* __tstate = wxPyBeginAllowThreads();
44754 (arg1)->SetString(arg2,(wxString const &)*arg3);
44755 wxPyEndAllowThreads(__tstate);
44756 if (PyErr_Occurred()) SWIG_fail;
44757 }
44758 resultobj = SWIG_Py_Void();
44759 {
44760 if (temp3)
44761 delete arg3;
44762 }
44763 return resultobj;
44764 fail:
44765 {
44766 if (temp3)
44767 delete arg3;
44768 }
44769 return NULL;
44770 }
44771
44772
44773 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44774 PyObject *resultobj = 0;
44775 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44776 wxString *arg2 = 0 ;
44777 int result;
44778 void *argp1 = 0 ;
44779 int res1 = 0 ;
44780 bool temp2 = false ;
44781 PyObject * obj0 = 0 ;
44782 PyObject * obj1 = 0 ;
44783 char * kwnames[] = {
44784 (char *) "self",(char *) "s", NULL
44785 };
44786
44787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44789 if (!SWIG_IsOK(res1)) {
44790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44791 }
44792 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44793 {
44794 arg2 = wxString_in_helper(obj1);
44795 if (arg2 == NULL) SWIG_fail;
44796 temp2 = true;
44797 }
44798 {
44799 PyThreadState* __tstate = wxPyBeginAllowThreads();
44800 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44801 wxPyEndAllowThreads(__tstate);
44802 if (PyErr_Occurred()) SWIG_fail;
44803 }
44804 resultobj = SWIG_From_int(static_cast< int >(result));
44805 {
44806 if (temp2)
44807 delete arg2;
44808 }
44809 return resultobj;
44810 fail:
44811 {
44812 if (temp2)
44813 delete arg2;
44814 }
44815 return NULL;
44816 }
44817
44818
44819 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44820 PyObject *resultobj = 0;
44821 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44822 int arg2 ;
44823 void *argp1 = 0 ;
44824 int res1 = 0 ;
44825 int val2 ;
44826 int ecode2 = 0 ;
44827 PyObject * obj0 = 0 ;
44828 PyObject * obj1 = 0 ;
44829 char * kwnames[] = {
44830 (char *) "self",(char *) "n", NULL
44831 };
44832
44833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44835 if (!SWIG_IsOK(res1)) {
44836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44837 }
44838 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44839 ecode2 = SWIG_AsVal_int(obj1, &val2);
44840 if (!SWIG_IsOK(ecode2)) {
44841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44842 }
44843 arg2 = static_cast< int >(val2);
44844 {
44845 PyThreadState* __tstate = wxPyBeginAllowThreads();
44846 (arg1)->SetSelection(arg2);
44847 wxPyEndAllowThreads(__tstate);
44848 if (PyErr_Occurred()) SWIG_fail;
44849 }
44850 resultobj = SWIG_Py_Void();
44851 return resultobj;
44852 fail:
44853 return NULL;
44854 }
44855
44856
44857 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44858 PyObject *resultobj = 0;
44859 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44860 int result;
44861 void *argp1 = 0 ;
44862 int res1 = 0 ;
44863 PyObject *swig_obj[1] ;
44864
44865 if (!args) SWIG_fail;
44866 swig_obj[0] = args;
44867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44868 if (!SWIG_IsOK(res1)) {
44869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44870 }
44871 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44872 {
44873 PyThreadState* __tstate = wxPyBeginAllowThreads();
44874 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44875 wxPyEndAllowThreads(__tstate);
44876 if (PyErr_Occurred()) SWIG_fail;
44877 }
44878 resultobj = SWIG_From_int(static_cast< int >(result));
44879 return resultobj;
44880 fail:
44881 return NULL;
44882 }
44883
44884
44885 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44886 PyObject *resultobj = 0;
44887 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44888 wxString *arg2 = 0 ;
44889 bool result;
44890 void *argp1 = 0 ;
44891 int res1 = 0 ;
44892 bool temp2 = false ;
44893 PyObject * obj0 = 0 ;
44894 PyObject * obj1 = 0 ;
44895 char * kwnames[] = {
44896 (char *) "self",(char *) "s", NULL
44897 };
44898
44899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44901 if (!SWIG_IsOK(res1)) {
44902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44903 }
44904 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44905 {
44906 arg2 = wxString_in_helper(obj1);
44907 if (arg2 == NULL) SWIG_fail;
44908 temp2 = true;
44909 }
44910 {
44911 PyThreadState* __tstate = wxPyBeginAllowThreads();
44912 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44913 wxPyEndAllowThreads(__tstate);
44914 if (PyErr_Occurred()) SWIG_fail;
44915 }
44916 {
44917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44918 }
44919 {
44920 if (temp2)
44921 delete arg2;
44922 }
44923 return resultobj;
44924 fail:
44925 {
44926 if (temp2)
44927 delete arg2;
44928 }
44929 return NULL;
44930 }
44931
44932
44933 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44934 PyObject *resultobj = 0;
44935 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44936 wxString result;
44937 void *argp1 = 0 ;
44938 int res1 = 0 ;
44939 PyObject *swig_obj[1] ;
44940
44941 if (!args) SWIG_fail;
44942 swig_obj[0] = args;
44943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44944 if (!SWIG_IsOK(res1)) {
44945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44946 }
44947 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44948 {
44949 PyThreadState* __tstate = wxPyBeginAllowThreads();
44950 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44951 wxPyEndAllowThreads(__tstate);
44952 if (PyErr_Occurred()) SWIG_fail;
44953 }
44954 {
44955 #if wxUSE_UNICODE
44956 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44957 #else
44958 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44959 #endif
44960 }
44961 return resultobj;
44962 fail:
44963 return NULL;
44964 }
44965
44966
44967 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44968 PyObject *resultobj = 0;
44969 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44970 int arg2 ;
44971 void *argp1 = 0 ;
44972 int res1 = 0 ;
44973 int val2 ;
44974 int ecode2 = 0 ;
44975 PyObject * obj0 = 0 ;
44976 PyObject * obj1 = 0 ;
44977 char * kwnames[] = {
44978 (char *) "self",(char *) "n", NULL
44979 };
44980
44981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44983 if (!SWIG_IsOK(res1)) {
44984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44985 }
44986 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44987 ecode2 = SWIG_AsVal_int(obj1, &val2);
44988 if (!SWIG_IsOK(ecode2)) {
44989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44990 }
44991 arg2 = static_cast< int >(val2);
44992 {
44993 PyThreadState* __tstate = wxPyBeginAllowThreads();
44994 (arg1)->Select(arg2);
44995 wxPyEndAllowThreads(__tstate);
44996 if (PyErr_Occurred()) SWIG_fail;
44997 }
44998 resultobj = SWIG_Py_Void();
44999 return resultobj;
45000 fail:
45001 return NULL;
45002 }
45003
45004
45005 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45006 PyObject *obj;
45007 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45008 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45009 return SWIG_Py_Void();
45010 }
45011
45012 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45013 PyObject *obj;
45014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45015 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45016 return SWIG_Py_Void();
45017 }
45018
45019 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45020 PyObject *resultobj = 0;
45021 wxSizerItem *result = 0 ;
45022
45023 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45024 {
45025 PyThreadState* __tstate = wxPyBeginAllowThreads();
45026 result = (wxSizerItem *)new wxSizerItem();
45027 wxPyEndAllowThreads(__tstate);
45028 if (PyErr_Occurred()) SWIG_fail;
45029 }
45030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45031 return resultobj;
45032 fail:
45033 return NULL;
45034 }
45035
45036
45037 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45038 PyObject *resultobj = 0;
45039 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45040 void *argp1 = 0 ;
45041 int res1 = 0 ;
45042 PyObject *swig_obj[1] ;
45043
45044 if (!args) SWIG_fail;
45045 swig_obj[0] = args;
45046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45047 if (!SWIG_IsOK(res1)) {
45048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45049 }
45050 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45051 {
45052 PyThreadState* __tstate = wxPyBeginAllowThreads();
45053 delete arg1;
45054
45055 wxPyEndAllowThreads(__tstate);
45056 if (PyErr_Occurred()) SWIG_fail;
45057 }
45058 resultobj = SWIG_Py_Void();
45059 return resultobj;
45060 fail:
45061 return NULL;
45062 }
45063
45064
45065 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45066 PyObject *resultobj = 0;
45067 wxWindow *arg1 = (wxWindow *) 0 ;
45068 int arg2 ;
45069 int arg3 ;
45070 int arg4 ;
45071 PyObject *arg5 = (PyObject *) NULL ;
45072 wxSizerItem *result = 0 ;
45073 void *argp1 = 0 ;
45074 int res1 = 0 ;
45075 int val2 ;
45076 int ecode2 = 0 ;
45077 int val3 ;
45078 int ecode3 = 0 ;
45079 int val4 ;
45080 int ecode4 = 0 ;
45081 PyObject * obj0 = 0 ;
45082 PyObject * obj1 = 0 ;
45083 PyObject * obj2 = 0 ;
45084 PyObject * obj3 = 0 ;
45085 PyObject * obj4 = 0 ;
45086 char * kwnames[] = {
45087 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45088 };
45089
45090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45092 if (!SWIG_IsOK(res1)) {
45093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45094 }
45095 arg1 = reinterpret_cast< wxWindow * >(argp1);
45096 ecode2 = SWIG_AsVal_int(obj1, &val2);
45097 if (!SWIG_IsOK(ecode2)) {
45098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45099 }
45100 arg2 = static_cast< int >(val2);
45101 ecode3 = SWIG_AsVal_int(obj2, &val3);
45102 if (!SWIG_IsOK(ecode3)) {
45103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45104 }
45105 arg3 = static_cast< int >(val3);
45106 ecode4 = SWIG_AsVal_int(obj3, &val4);
45107 if (!SWIG_IsOK(ecode4)) {
45108 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45109 }
45110 arg4 = static_cast< int >(val4);
45111 if (obj4) {
45112 arg5 = obj4;
45113 }
45114 {
45115 PyThreadState* __tstate = wxPyBeginAllowThreads();
45116 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45117 wxPyEndAllowThreads(__tstate);
45118 if (PyErr_Occurred()) SWIG_fail;
45119 }
45120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45121 return resultobj;
45122 fail:
45123 return NULL;
45124 }
45125
45126
45127 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45128 PyObject *resultobj = 0;
45129 int arg1 ;
45130 int arg2 ;
45131 int arg3 ;
45132 int arg4 ;
45133 int arg5 ;
45134 PyObject *arg6 = (PyObject *) NULL ;
45135 wxSizerItem *result = 0 ;
45136 int val1 ;
45137 int ecode1 = 0 ;
45138 int val2 ;
45139 int ecode2 = 0 ;
45140 int val3 ;
45141 int ecode3 = 0 ;
45142 int val4 ;
45143 int ecode4 = 0 ;
45144 int val5 ;
45145 int ecode5 = 0 ;
45146 PyObject * obj0 = 0 ;
45147 PyObject * obj1 = 0 ;
45148 PyObject * obj2 = 0 ;
45149 PyObject * obj3 = 0 ;
45150 PyObject * obj4 = 0 ;
45151 PyObject * obj5 = 0 ;
45152 char * kwnames[] = {
45153 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45154 };
45155
45156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45157 ecode1 = SWIG_AsVal_int(obj0, &val1);
45158 if (!SWIG_IsOK(ecode1)) {
45159 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45160 }
45161 arg1 = static_cast< int >(val1);
45162 ecode2 = SWIG_AsVal_int(obj1, &val2);
45163 if (!SWIG_IsOK(ecode2)) {
45164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45165 }
45166 arg2 = static_cast< int >(val2);
45167 ecode3 = SWIG_AsVal_int(obj2, &val3);
45168 if (!SWIG_IsOK(ecode3)) {
45169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45170 }
45171 arg3 = static_cast< int >(val3);
45172 ecode4 = SWIG_AsVal_int(obj3, &val4);
45173 if (!SWIG_IsOK(ecode4)) {
45174 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45175 }
45176 arg4 = static_cast< int >(val4);
45177 ecode5 = SWIG_AsVal_int(obj4, &val5);
45178 if (!SWIG_IsOK(ecode5)) {
45179 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45180 }
45181 arg5 = static_cast< int >(val5);
45182 if (obj5) {
45183 arg6 = obj5;
45184 }
45185 {
45186 PyThreadState* __tstate = wxPyBeginAllowThreads();
45187 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45188 wxPyEndAllowThreads(__tstate);
45189 if (PyErr_Occurred()) SWIG_fail;
45190 }
45191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45192 return resultobj;
45193 fail:
45194 return NULL;
45195 }
45196
45197
45198 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45199 PyObject *resultobj = 0;
45200 wxSizer *arg1 = (wxSizer *) 0 ;
45201 int arg2 ;
45202 int arg3 ;
45203 int arg4 ;
45204 PyObject *arg5 = (PyObject *) NULL ;
45205 wxSizerItem *result = 0 ;
45206 int res1 = 0 ;
45207 int val2 ;
45208 int ecode2 = 0 ;
45209 int val3 ;
45210 int ecode3 = 0 ;
45211 int val4 ;
45212 int ecode4 = 0 ;
45213 PyObject * obj0 = 0 ;
45214 PyObject * obj1 = 0 ;
45215 PyObject * obj2 = 0 ;
45216 PyObject * obj3 = 0 ;
45217 PyObject * obj4 = 0 ;
45218 char * kwnames[] = {
45219 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45220 };
45221
45222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45223 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45224 if (!SWIG_IsOK(res1)) {
45225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45226 }
45227 ecode2 = SWIG_AsVal_int(obj1, &val2);
45228 if (!SWIG_IsOK(ecode2)) {
45229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45230 }
45231 arg2 = static_cast< int >(val2);
45232 ecode3 = SWIG_AsVal_int(obj2, &val3);
45233 if (!SWIG_IsOK(ecode3)) {
45234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45235 }
45236 arg3 = static_cast< int >(val3);
45237 ecode4 = SWIG_AsVal_int(obj3, &val4);
45238 if (!SWIG_IsOK(ecode4)) {
45239 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45240 }
45241 arg4 = static_cast< int >(val4);
45242 if (obj4) {
45243 arg5 = obj4;
45244 }
45245 {
45246 PyThreadState* __tstate = wxPyBeginAllowThreads();
45247 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45248 wxPyEndAllowThreads(__tstate);
45249 if (PyErr_Occurred()) SWIG_fail;
45250 }
45251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45252 return resultobj;
45253 fail:
45254 return NULL;
45255 }
45256
45257
45258 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45259 PyObject *resultobj = 0;
45260 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45261 void *argp1 = 0 ;
45262 int res1 = 0 ;
45263 PyObject *swig_obj[1] ;
45264
45265 if (!args) SWIG_fail;
45266 swig_obj[0] = args;
45267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45268 if (!SWIG_IsOK(res1)) {
45269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45270 }
45271 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45272 {
45273 PyThreadState* __tstate = wxPyBeginAllowThreads();
45274 (arg1)->DeleteWindows();
45275 wxPyEndAllowThreads(__tstate);
45276 if (PyErr_Occurred()) SWIG_fail;
45277 }
45278 resultobj = SWIG_Py_Void();
45279 return resultobj;
45280 fail:
45281 return NULL;
45282 }
45283
45284
45285 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45286 PyObject *resultobj = 0;
45287 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45288 void *argp1 = 0 ;
45289 int res1 = 0 ;
45290 PyObject *swig_obj[1] ;
45291
45292 if (!args) SWIG_fail;
45293 swig_obj[0] = args;
45294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45295 if (!SWIG_IsOK(res1)) {
45296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45297 }
45298 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45299 {
45300 PyThreadState* __tstate = wxPyBeginAllowThreads();
45301 (arg1)->DetachSizer();
45302 wxPyEndAllowThreads(__tstate);
45303 if (PyErr_Occurred()) SWIG_fail;
45304 }
45305 resultobj = SWIG_Py_Void();
45306 return resultobj;
45307 fail:
45308 return NULL;
45309 }
45310
45311
45312 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45313 PyObject *resultobj = 0;
45314 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45315 wxSize result;
45316 void *argp1 = 0 ;
45317 int res1 = 0 ;
45318 PyObject *swig_obj[1] ;
45319
45320 if (!args) SWIG_fail;
45321 swig_obj[0] = args;
45322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45323 if (!SWIG_IsOK(res1)) {
45324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45325 }
45326 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45327 {
45328 PyThreadState* __tstate = wxPyBeginAllowThreads();
45329 result = (arg1)->GetSize();
45330 wxPyEndAllowThreads(__tstate);
45331 if (PyErr_Occurred()) SWIG_fail;
45332 }
45333 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45334 return resultobj;
45335 fail:
45336 return NULL;
45337 }
45338
45339
45340 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45341 PyObject *resultobj = 0;
45342 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45343 wxSize result;
45344 void *argp1 = 0 ;
45345 int res1 = 0 ;
45346 PyObject *swig_obj[1] ;
45347
45348 if (!args) SWIG_fail;
45349 swig_obj[0] = args;
45350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45351 if (!SWIG_IsOK(res1)) {
45352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45353 }
45354 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45355 {
45356 PyThreadState* __tstate = wxPyBeginAllowThreads();
45357 result = (arg1)->CalcMin();
45358 wxPyEndAllowThreads(__tstate);
45359 if (PyErr_Occurred()) SWIG_fail;
45360 }
45361 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45362 return resultobj;
45363 fail:
45364 return NULL;
45365 }
45366
45367
45368 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45369 PyObject *resultobj = 0;
45370 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45371 wxPoint *arg2 = 0 ;
45372 wxSize *arg3 = 0 ;
45373 void *argp1 = 0 ;
45374 int res1 = 0 ;
45375 wxPoint temp2 ;
45376 wxSize temp3 ;
45377 PyObject * obj0 = 0 ;
45378 PyObject * obj1 = 0 ;
45379 PyObject * obj2 = 0 ;
45380 char * kwnames[] = {
45381 (char *) "self",(char *) "pos",(char *) "size", NULL
45382 };
45383
45384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45386 if (!SWIG_IsOK(res1)) {
45387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45388 }
45389 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45390 {
45391 arg2 = &temp2;
45392 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45393 }
45394 {
45395 arg3 = &temp3;
45396 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45397 }
45398 {
45399 PyThreadState* __tstate = wxPyBeginAllowThreads();
45400 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45401 wxPyEndAllowThreads(__tstate);
45402 if (PyErr_Occurred()) SWIG_fail;
45403 }
45404 resultobj = SWIG_Py_Void();
45405 return resultobj;
45406 fail:
45407 return NULL;
45408 }
45409
45410
45411 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45412 PyObject *resultobj = 0;
45413 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45414 wxSize result;
45415 void *argp1 = 0 ;
45416 int res1 = 0 ;
45417 PyObject *swig_obj[1] ;
45418
45419 if (!args) SWIG_fail;
45420 swig_obj[0] = args;
45421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45422 if (!SWIG_IsOK(res1)) {
45423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45424 }
45425 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45426 {
45427 PyThreadState* __tstate = wxPyBeginAllowThreads();
45428 result = (arg1)->GetMinSize();
45429 wxPyEndAllowThreads(__tstate);
45430 if (PyErr_Occurred()) SWIG_fail;
45431 }
45432 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45433 return resultobj;
45434 fail:
45435 return NULL;
45436 }
45437
45438
45439 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45440 PyObject *resultobj = 0;
45441 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45442 wxSize result;
45443 void *argp1 = 0 ;
45444 int res1 = 0 ;
45445 PyObject *swig_obj[1] ;
45446
45447 if (!args) SWIG_fail;
45448 swig_obj[0] = args;
45449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45450 if (!SWIG_IsOK(res1)) {
45451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45452 }
45453 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45454 {
45455 PyThreadState* __tstate = wxPyBeginAllowThreads();
45456 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45457 wxPyEndAllowThreads(__tstate);
45458 if (PyErr_Occurred()) SWIG_fail;
45459 }
45460 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45461 return resultobj;
45462 fail:
45463 return NULL;
45464 }
45465
45466
45467 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45468 PyObject *resultobj = 0;
45469 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45470 int arg2 ;
45471 int arg3 ;
45472 void *argp1 = 0 ;
45473 int res1 = 0 ;
45474 int val2 ;
45475 int ecode2 = 0 ;
45476 int val3 ;
45477 int ecode3 = 0 ;
45478 PyObject * obj0 = 0 ;
45479 PyObject * obj1 = 0 ;
45480 PyObject * obj2 = 0 ;
45481 char * kwnames[] = {
45482 (char *) "self",(char *) "x",(char *) "y", NULL
45483 };
45484
45485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45487 if (!SWIG_IsOK(res1)) {
45488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45489 }
45490 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45491 ecode2 = SWIG_AsVal_int(obj1, &val2);
45492 if (!SWIG_IsOK(ecode2)) {
45493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45494 }
45495 arg2 = static_cast< int >(val2);
45496 ecode3 = SWIG_AsVal_int(obj2, &val3);
45497 if (!SWIG_IsOK(ecode3)) {
45498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45499 }
45500 arg3 = static_cast< int >(val3);
45501 {
45502 PyThreadState* __tstate = wxPyBeginAllowThreads();
45503 (arg1)->SetInitSize(arg2,arg3);
45504 wxPyEndAllowThreads(__tstate);
45505 if (PyErr_Occurred()) SWIG_fail;
45506 }
45507 resultobj = SWIG_Py_Void();
45508 return resultobj;
45509 fail:
45510 return NULL;
45511 }
45512
45513
45514 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45515 PyObject *resultobj = 0;
45516 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45517 int arg2 ;
45518 int arg3 ;
45519 void *argp1 = 0 ;
45520 int res1 = 0 ;
45521 int val2 ;
45522 int ecode2 = 0 ;
45523 int val3 ;
45524 int ecode3 = 0 ;
45525 PyObject * obj0 = 0 ;
45526 PyObject * obj1 = 0 ;
45527 PyObject * obj2 = 0 ;
45528 char * kwnames[] = {
45529 (char *) "self",(char *) "width",(char *) "height", NULL
45530 };
45531
45532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45534 if (!SWIG_IsOK(res1)) {
45535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45536 }
45537 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45538 ecode2 = SWIG_AsVal_int(obj1, &val2);
45539 if (!SWIG_IsOK(ecode2)) {
45540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45541 }
45542 arg2 = static_cast< int >(val2);
45543 ecode3 = SWIG_AsVal_int(obj2, &val3);
45544 if (!SWIG_IsOK(ecode3)) {
45545 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45546 }
45547 arg3 = static_cast< int >(val3);
45548 {
45549 PyThreadState* __tstate = wxPyBeginAllowThreads();
45550 (arg1)->SetRatio(arg2,arg3);
45551 wxPyEndAllowThreads(__tstate);
45552 if (PyErr_Occurred()) SWIG_fail;
45553 }
45554 resultobj = SWIG_Py_Void();
45555 return resultobj;
45556 fail:
45557 return NULL;
45558 }
45559
45560
45561 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45562 PyObject *resultobj = 0;
45563 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45564 wxSize *arg2 = 0 ;
45565 void *argp1 = 0 ;
45566 int res1 = 0 ;
45567 wxSize temp2 ;
45568 PyObject * obj0 = 0 ;
45569 PyObject * obj1 = 0 ;
45570 char * kwnames[] = {
45571 (char *) "self",(char *) "size", NULL
45572 };
45573
45574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45576 if (!SWIG_IsOK(res1)) {
45577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45578 }
45579 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45580 {
45581 arg2 = &temp2;
45582 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45583 }
45584 {
45585 PyThreadState* __tstate = wxPyBeginAllowThreads();
45586 (arg1)->SetRatio((wxSize const &)*arg2);
45587 wxPyEndAllowThreads(__tstate);
45588 if (PyErr_Occurred()) SWIG_fail;
45589 }
45590 resultobj = SWIG_Py_Void();
45591 return resultobj;
45592 fail:
45593 return NULL;
45594 }
45595
45596
45597 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45598 PyObject *resultobj = 0;
45599 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45600 float arg2 ;
45601 void *argp1 = 0 ;
45602 int res1 = 0 ;
45603 float val2 ;
45604 int ecode2 = 0 ;
45605 PyObject * obj0 = 0 ;
45606 PyObject * obj1 = 0 ;
45607 char * kwnames[] = {
45608 (char *) "self",(char *) "ratio", NULL
45609 };
45610
45611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45613 if (!SWIG_IsOK(res1)) {
45614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45615 }
45616 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45617 ecode2 = SWIG_AsVal_float(obj1, &val2);
45618 if (!SWIG_IsOK(ecode2)) {
45619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45620 }
45621 arg2 = static_cast< float >(val2);
45622 {
45623 PyThreadState* __tstate = wxPyBeginAllowThreads();
45624 (arg1)->SetRatio(arg2);
45625 wxPyEndAllowThreads(__tstate);
45626 if (PyErr_Occurred()) SWIG_fail;
45627 }
45628 resultobj = SWIG_Py_Void();
45629 return resultobj;
45630 fail:
45631 return NULL;
45632 }
45633
45634
45635 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45636 PyObject *resultobj = 0;
45637 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45638 float result;
45639 void *argp1 = 0 ;
45640 int res1 = 0 ;
45641 PyObject *swig_obj[1] ;
45642
45643 if (!args) SWIG_fail;
45644 swig_obj[0] = args;
45645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45646 if (!SWIG_IsOK(res1)) {
45647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45648 }
45649 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45650 {
45651 PyThreadState* __tstate = wxPyBeginAllowThreads();
45652 result = (float)(arg1)->GetRatio();
45653 wxPyEndAllowThreads(__tstate);
45654 if (PyErr_Occurred()) SWIG_fail;
45655 }
45656 resultobj = SWIG_From_float(static_cast< float >(result));
45657 return resultobj;
45658 fail:
45659 return NULL;
45660 }
45661
45662
45663 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45664 PyObject *resultobj = 0;
45665 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45666 wxRect result;
45667 void *argp1 = 0 ;
45668 int res1 = 0 ;
45669 PyObject *swig_obj[1] ;
45670
45671 if (!args) SWIG_fail;
45672 swig_obj[0] = args;
45673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45674 if (!SWIG_IsOK(res1)) {
45675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45676 }
45677 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45678 {
45679 PyThreadState* __tstate = wxPyBeginAllowThreads();
45680 result = (arg1)->GetRect();
45681 wxPyEndAllowThreads(__tstate);
45682 if (PyErr_Occurred()) SWIG_fail;
45683 }
45684 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45685 return resultobj;
45686 fail:
45687 return NULL;
45688 }
45689
45690
45691 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45692 PyObject *resultobj = 0;
45693 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45694 bool result;
45695 void *argp1 = 0 ;
45696 int res1 = 0 ;
45697 PyObject *swig_obj[1] ;
45698
45699 if (!args) SWIG_fail;
45700 swig_obj[0] = args;
45701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45702 if (!SWIG_IsOK(res1)) {
45703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45704 }
45705 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45706 {
45707 PyThreadState* __tstate = wxPyBeginAllowThreads();
45708 result = (bool)(arg1)->IsWindow();
45709 wxPyEndAllowThreads(__tstate);
45710 if (PyErr_Occurred()) SWIG_fail;
45711 }
45712 {
45713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45714 }
45715 return resultobj;
45716 fail:
45717 return NULL;
45718 }
45719
45720
45721 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45722 PyObject *resultobj = 0;
45723 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45724 bool result;
45725 void *argp1 = 0 ;
45726 int res1 = 0 ;
45727 PyObject *swig_obj[1] ;
45728
45729 if (!args) SWIG_fail;
45730 swig_obj[0] = args;
45731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45732 if (!SWIG_IsOK(res1)) {
45733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45734 }
45735 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45736 {
45737 PyThreadState* __tstate = wxPyBeginAllowThreads();
45738 result = (bool)(arg1)->IsSizer();
45739 wxPyEndAllowThreads(__tstate);
45740 if (PyErr_Occurred()) SWIG_fail;
45741 }
45742 {
45743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45744 }
45745 return resultobj;
45746 fail:
45747 return NULL;
45748 }
45749
45750
45751 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45752 PyObject *resultobj = 0;
45753 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45754 bool result;
45755 void *argp1 = 0 ;
45756 int res1 = 0 ;
45757 PyObject *swig_obj[1] ;
45758
45759 if (!args) SWIG_fail;
45760 swig_obj[0] = args;
45761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45762 if (!SWIG_IsOK(res1)) {
45763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45764 }
45765 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45766 {
45767 PyThreadState* __tstate = wxPyBeginAllowThreads();
45768 result = (bool)(arg1)->IsSpacer();
45769 wxPyEndAllowThreads(__tstate);
45770 if (PyErr_Occurred()) SWIG_fail;
45771 }
45772 {
45773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45774 }
45775 return resultobj;
45776 fail:
45777 return NULL;
45778 }
45779
45780
45781 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45782 PyObject *resultobj = 0;
45783 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45784 int arg2 ;
45785 void *argp1 = 0 ;
45786 int res1 = 0 ;
45787 int val2 ;
45788 int ecode2 = 0 ;
45789 PyObject * obj0 = 0 ;
45790 PyObject * obj1 = 0 ;
45791 char * kwnames[] = {
45792 (char *) "self",(char *) "proportion", NULL
45793 };
45794
45795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45797 if (!SWIG_IsOK(res1)) {
45798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45799 }
45800 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45801 ecode2 = SWIG_AsVal_int(obj1, &val2);
45802 if (!SWIG_IsOK(ecode2)) {
45803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45804 }
45805 arg2 = static_cast< int >(val2);
45806 {
45807 PyThreadState* __tstate = wxPyBeginAllowThreads();
45808 (arg1)->SetProportion(arg2);
45809 wxPyEndAllowThreads(__tstate);
45810 if (PyErr_Occurred()) SWIG_fail;
45811 }
45812 resultobj = SWIG_Py_Void();
45813 return resultobj;
45814 fail:
45815 return NULL;
45816 }
45817
45818
45819 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45820 PyObject *resultobj = 0;
45821 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45822 int result;
45823 void *argp1 = 0 ;
45824 int res1 = 0 ;
45825 PyObject *swig_obj[1] ;
45826
45827 if (!args) SWIG_fail;
45828 swig_obj[0] = args;
45829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45830 if (!SWIG_IsOK(res1)) {
45831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45832 }
45833 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45834 {
45835 PyThreadState* __tstate = wxPyBeginAllowThreads();
45836 result = (int)(arg1)->GetProportion();
45837 wxPyEndAllowThreads(__tstate);
45838 if (PyErr_Occurred()) SWIG_fail;
45839 }
45840 resultobj = SWIG_From_int(static_cast< int >(result));
45841 return resultobj;
45842 fail:
45843 return NULL;
45844 }
45845
45846
45847 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45848 PyObject *resultobj = 0;
45849 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45850 int arg2 ;
45851 void *argp1 = 0 ;
45852 int res1 = 0 ;
45853 int val2 ;
45854 int ecode2 = 0 ;
45855 PyObject * obj0 = 0 ;
45856 PyObject * obj1 = 0 ;
45857 char * kwnames[] = {
45858 (char *) "self",(char *) "flag", NULL
45859 };
45860
45861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45863 if (!SWIG_IsOK(res1)) {
45864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45865 }
45866 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45867 ecode2 = SWIG_AsVal_int(obj1, &val2);
45868 if (!SWIG_IsOK(ecode2)) {
45869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45870 }
45871 arg2 = static_cast< int >(val2);
45872 {
45873 PyThreadState* __tstate = wxPyBeginAllowThreads();
45874 (arg1)->SetFlag(arg2);
45875 wxPyEndAllowThreads(__tstate);
45876 if (PyErr_Occurred()) SWIG_fail;
45877 }
45878 resultobj = SWIG_Py_Void();
45879 return resultobj;
45880 fail:
45881 return NULL;
45882 }
45883
45884
45885 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45886 PyObject *resultobj = 0;
45887 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45888 int result;
45889 void *argp1 = 0 ;
45890 int res1 = 0 ;
45891 PyObject *swig_obj[1] ;
45892
45893 if (!args) SWIG_fail;
45894 swig_obj[0] = args;
45895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45896 if (!SWIG_IsOK(res1)) {
45897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45898 }
45899 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45900 {
45901 PyThreadState* __tstate = wxPyBeginAllowThreads();
45902 result = (int)(arg1)->GetFlag();
45903 wxPyEndAllowThreads(__tstate);
45904 if (PyErr_Occurred()) SWIG_fail;
45905 }
45906 resultobj = SWIG_From_int(static_cast< int >(result));
45907 return resultobj;
45908 fail:
45909 return NULL;
45910 }
45911
45912
45913 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45914 PyObject *resultobj = 0;
45915 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45916 int arg2 ;
45917 void *argp1 = 0 ;
45918 int res1 = 0 ;
45919 int val2 ;
45920 int ecode2 = 0 ;
45921 PyObject * obj0 = 0 ;
45922 PyObject * obj1 = 0 ;
45923 char * kwnames[] = {
45924 (char *) "self",(char *) "border", NULL
45925 };
45926
45927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45929 if (!SWIG_IsOK(res1)) {
45930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45931 }
45932 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45933 ecode2 = SWIG_AsVal_int(obj1, &val2);
45934 if (!SWIG_IsOK(ecode2)) {
45935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45936 }
45937 arg2 = static_cast< int >(val2);
45938 {
45939 PyThreadState* __tstate = wxPyBeginAllowThreads();
45940 (arg1)->SetBorder(arg2);
45941 wxPyEndAllowThreads(__tstate);
45942 if (PyErr_Occurred()) SWIG_fail;
45943 }
45944 resultobj = SWIG_Py_Void();
45945 return resultobj;
45946 fail:
45947 return NULL;
45948 }
45949
45950
45951 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45952 PyObject *resultobj = 0;
45953 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45954 int result;
45955 void *argp1 = 0 ;
45956 int res1 = 0 ;
45957 PyObject *swig_obj[1] ;
45958
45959 if (!args) SWIG_fail;
45960 swig_obj[0] = args;
45961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45962 if (!SWIG_IsOK(res1)) {
45963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45964 }
45965 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45966 {
45967 PyThreadState* __tstate = wxPyBeginAllowThreads();
45968 result = (int)(arg1)->GetBorder();
45969 wxPyEndAllowThreads(__tstate);
45970 if (PyErr_Occurred()) SWIG_fail;
45971 }
45972 resultobj = SWIG_From_int(static_cast< int >(result));
45973 return resultobj;
45974 fail:
45975 return NULL;
45976 }
45977
45978
45979 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45980 PyObject *resultobj = 0;
45981 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45982 wxWindow *result = 0 ;
45983 void *argp1 = 0 ;
45984 int res1 = 0 ;
45985 PyObject *swig_obj[1] ;
45986
45987 if (!args) SWIG_fail;
45988 swig_obj[0] = args;
45989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45990 if (!SWIG_IsOK(res1)) {
45991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45992 }
45993 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45994 {
45995 PyThreadState* __tstate = wxPyBeginAllowThreads();
45996 result = (wxWindow *)(arg1)->GetWindow();
45997 wxPyEndAllowThreads(__tstate);
45998 if (PyErr_Occurred()) SWIG_fail;
45999 }
46000 {
46001 resultobj = wxPyMake_wxObject(result, 0);
46002 }
46003 return resultobj;
46004 fail:
46005 return NULL;
46006 }
46007
46008
46009 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46010 PyObject *resultobj = 0;
46011 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46012 wxWindow *arg2 = (wxWindow *) 0 ;
46013 void *argp1 = 0 ;
46014 int res1 = 0 ;
46015 void *argp2 = 0 ;
46016 int res2 = 0 ;
46017 PyObject * obj0 = 0 ;
46018 PyObject * obj1 = 0 ;
46019 char * kwnames[] = {
46020 (char *) "self",(char *) "window", NULL
46021 };
46022
46023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46025 if (!SWIG_IsOK(res1)) {
46026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46027 }
46028 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46029 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46030 if (!SWIG_IsOK(res2)) {
46031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46032 }
46033 arg2 = reinterpret_cast< wxWindow * >(argp2);
46034 {
46035 PyThreadState* __tstate = wxPyBeginAllowThreads();
46036 (arg1)->SetWindow(arg2);
46037 wxPyEndAllowThreads(__tstate);
46038 if (PyErr_Occurred()) SWIG_fail;
46039 }
46040 resultobj = SWIG_Py_Void();
46041 return resultobj;
46042 fail:
46043 return NULL;
46044 }
46045
46046
46047 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46048 PyObject *resultobj = 0;
46049 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46050 wxSizer *result = 0 ;
46051 void *argp1 = 0 ;
46052 int res1 = 0 ;
46053 PyObject *swig_obj[1] ;
46054
46055 if (!args) SWIG_fail;
46056 swig_obj[0] = args;
46057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46058 if (!SWIG_IsOK(res1)) {
46059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46060 }
46061 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46062 {
46063 PyThreadState* __tstate = wxPyBeginAllowThreads();
46064 result = (wxSizer *)(arg1)->GetSizer();
46065 wxPyEndAllowThreads(__tstate);
46066 if (PyErr_Occurred()) SWIG_fail;
46067 }
46068 {
46069 resultobj = wxPyMake_wxObject(result, (bool)0);
46070 }
46071 return resultobj;
46072 fail:
46073 return NULL;
46074 }
46075
46076
46077 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46078 PyObject *resultobj = 0;
46079 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46080 wxSizer *arg2 = (wxSizer *) 0 ;
46081 void *argp1 = 0 ;
46082 int res1 = 0 ;
46083 int res2 = 0 ;
46084 PyObject * obj0 = 0 ;
46085 PyObject * obj1 = 0 ;
46086 char * kwnames[] = {
46087 (char *) "self",(char *) "sizer", NULL
46088 };
46089
46090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46092 if (!SWIG_IsOK(res1)) {
46093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46094 }
46095 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46096 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46097 if (!SWIG_IsOK(res2)) {
46098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46099 }
46100 {
46101 PyThreadState* __tstate = wxPyBeginAllowThreads();
46102 (arg1)->SetSizer(arg2);
46103 wxPyEndAllowThreads(__tstate);
46104 if (PyErr_Occurred()) SWIG_fail;
46105 }
46106 resultobj = SWIG_Py_Void();
46107 return resultobj;
46108 fail:
46109 return NULL;
46110 }
46111
46112
46113 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46114 PyObject *resultobj = 0;
46115 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46116 wxSize *result = 0 ;
46117 void *argp1 = 0 ;
46118 int res1 = 0 ;
46119 PyObject *swig_obj[1] ;
46120
46121 if (!args) SWIG_fail;
46122 swig_obj[0] = args;
46123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46124 if (!SWIG_IsOK(res1)) {
46125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46126 }
46127 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46128 {
46129 PyThreadState* __tstate = wxPyBeginAllowThreads();
46130 {
46131 wxSize const &_result_ref = (arg1)->GetSpacer();
46132 result = (wxSize *) &_result_ref;
46133 }
46134 wxPyEndAllowThreads(__tstate);
46135 if (PyErr_Occurred()) SWIG_fail;
46136 }
46137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46138 return resultobj;
46139 fail:
46140 return NULL;
46141 }
46142
46143
46144 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46145 PyObject *resultobj = 0;
46146 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46147 wxSize *arg2 = 0 ;
46148 void *argp1 = 0 ;
46149 int res1 = 0 ;
46150 wxSize temp2 ;
46151 PyObject * obj0 = 0 ;
46152 PyObject * obj1 = 0 ;
46153 char * kwnames[] = {
46154 (char *) "self",(char *) "size", NULL
46155 };
46156
46157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46159 if (!SWIG_IsOK(res1)) {
46160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46161 }
46162 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46163 {
46164 arg2 = &temp2;
46165 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46166 }
46167 {
46168 PyThreadState* __tstate = wxPyBeginAllowThreads();
46169 (arg1)->SetSpacer((wxSize const &)*arg2);
46170 wxPyEndAllowThreads(__tstate);
46171 if (PyErr_Occurred()) SWIG_fail;
46172 }
46173 resultobj = SWIG_Py_Void();
46174 return resultobj;
46175 fail:
46176 return NULL;
46177 }
46178
46179
46180 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46181 PyObject *resultobj = 0;
46182 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46183 bool arg2 ;
46184 void *argp1 = 0 ;
46185 int res1 = 0 ;
46186 bool val2 ;
46187 int ecode2 = 0 ;
46188 PyObject * obj0 = 0 ;
46189 PyObject * obj1 = 0 ;
46190 char * kwnames[] = {
46191 (char *) "self",(char *) "show", NULL
46192 };
46193
46194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46196 if (!SWIG_IsOK(res1)) {
46197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46198 }
46199 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46200 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46201 if (!SWIG_IsOK(ecode2)) {
46202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46203 }
46204 arg2 = static_cast< bool >(val2);
46205 {
46206 PyThreadState* __tstate = wxPyBeginAllowThreads();
46207 (arg1)->Show(arg2);
46208 wxPyEndAllowThreads(__tstate);
46209 if (PyErr_Occurred()) SWIG_fail;
46210 }
46211 resultobj = SWIG_Py_Void();
46212 return resultobj;
46213 fail:
46214 return NULL;
46215 }
46216
46217
46218 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46219 PyObject *resultobj = 0;
46220 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46221 bool result;
46222 void *argp1 = 0 ;
46223 int res1 = 0 ;
46224 PyObject *swig_obj[1] ;
46225
46226 if (!args) SWIG_fail;
46227 swig_obj[0] = args;
46228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46229 if (!SWIG_IsOK(res1)) {
46230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46231 }
46232 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46233 {
46234 PyThreadState* __tstate = wxPyBeginAllowThreads();
46235 result = (bool)(arg1)->IsShown();
46236 wxPyEndAllowThreads(__tstate);
46237 if (PyErr_Occurred()) SWIG_fail;
46238 }
46239 {
46240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46241 }
46242 return resultobj;
46243 fail:
46244 return NULL;
46245 }
46246
46247
46248 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46249 PyObject *resultobj = 0;
46250 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46251 wxPoint result;
46252 void *argp1 = 0 ;
46253 int res1 = 0 ;
46254 PyObject *swig_obj[1] ;
46255
46256 if (!args) SWIG_fail;
46257 swig_obj[0] = args;
46258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46259 if (!SWIG_IsOK(res1)) {
46260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46261 }
46262 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46263 {
46264 PyThreadState* __tstate = wxPyBeginAllowThreads();
46265 result = (arg1)->GetPosition();
46266 wxPyEndAllowThreads(__tstate);
46267 if (PyErr_Occurred()) SWIG_fail;
46268 }
46269 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46270 return resultobj;
46271 fail:
46272 return NULL;
46273 }
46274
46275
46276 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46277 PyObject *resultobj = 0;
46278 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46279 PyObject *result = 0 ;
46280 void *argp1 = 0 ;
46281 int res1 = 0 ;
46282 PyObject *swig_obj[1] ;
46283
46284 if (!args) SWIG_fail;
46285 swig_obj[0] = args;
46286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46287 if (!SWIG_IsOK(res1)) {
46288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46289 }
46290 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46291 {
46292 PyThreadState* __tstate = wxPyBeginAllowThreads();
46293 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46294 wxPyEndAllowThreads(__tstate);
46295 if (PyErr_Occurred()) SWIG_fail;
46296 }
46297 resultobj = result;
46298 return resultobj;
46299 fail:
46300 return NULL;
46301 }
46302
46303
46304 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46305 PyObject *resultobj = 0;
46306 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46307 PyObject *arg2 = (PyObject *) 0 ;
46308 void *argp1 = 0 ;
46309 int res1 = 0 ;
46310 PyObject * obj0 = 0 ;
46311 PyObject * obj1 = 0 ;
46312 char * kwnames[] = {
46313 (char *) "self",(char *) "userData", NULL
46314 };
46315
46316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46318 if (!SWIG_IsOK(res1)) {
46319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46320 }
46321 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46322 arg2 = obj1;
46323 {
46324 PyThreadState* __tstate = wxPyBeginAllowThreads();
46325 wxSizerItem_SetUserData(arg1,arg2);
46326 wxPyEndAllowThreads(__tstate);
46327 if (PyErr_Occurred()) SWIG_fail;
46328 }
46329 resultobj = SWIG_Py_Void();
46330 return resultobj;
46331 fail:
46332 return NULL;
46333 }
46334
46335
46336 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46337 PyObject *obj;
46338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46339 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46340 return SWIG_Py_Void();
46341 }
46342
46343 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46344 return SWIG_Python_InitShadowInstance(args);
46345 }
46346
46347 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46348 PyObject *resultobj = 0;
46349 wxSizer *arg1 = (wxSizer *) 0 ;
46350 void *argp1 = 0 ;
46351 int res1 = 0 ;
46352 PyObject *swig_obj[1] ;
46353
46354 if (!args) SWIG_fail;
46355 swig_obj[0] = args;
46356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46357 if (!SWIG_IsOK(res1)) {
46358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46359 }
46360 arg1 = reinterpret_cast< wxSizer * >(argp1);
46361 {
46362 PyThreadState* __tstate = wxPyBeginAllowThreads();
46363 delete arg1;
46364
46365 wxPyEndAllowThreads(__tstate);
46366 if (PyErr_Occurred()) SWIG_fail;
46367 }
46368 resultobj = SWIG_Py_Void();
46369 return resultobj;
46370 fail:
46371 return NULL;
46372 }
46373
46374
46375 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46376 PyObject *resultobj = 0;
46377 wxSizer *arg1 = (wxSizer *) 0 ;
46378 PyObject *arg2 = (PyObject *) 0 ;
46379 void *argp1 = 0 ;
46380 int res1 = 0 ;
46381 PyObject * obj0 = 0 ;
46382 PyObject * obj1 = 0 ;
46383 char * kwnames[] = {
46384 (char *) "self",(char *) "_self", NULL
46385 };
46386
46387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46389 if (!SWIG_IsOK(res1)) {
46390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46391 }
46392 arg1 = reinterpret_cast< wxSizer * >(argp1);
46393 arg2 = obj1;
46394 {
46395 PyThreadState* __tstate = wxPyBeginAllowThreads();
46396 wxSizer__setOORInfo(arg1,arg2);
46397 wxPyEndAllowThreads(__tstate);
46398 if (PyErr_Occurred()) SWIG_fail;
46399 }
46400 resultobj = SWIG_Py_Void();
46401 return resultobj;
46402 fail:
46403 return NULL;
46404 }
46405
46406
46407 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46408 PyObject *resultobj = 0;
46409 wxSizer *arg1 = (wxSizer *) 0 ;
46410 PyObject *arg2 = (PyObject *) 0 ;
46411 int arg3 = (int) 0 ;
46412 int arg4 = (int) 0 ;
46413 int arg5 = (int) 0 ;
46414 PyObject *arg6 = (PyObject *) NULL ;
46415 wxSizerItem *result = 0 ;
46416 void *argp1 = 0 ;
46417 int res1 = 0 ;
46418 int val3 ;
46419 int ecode3 = 0 ;
46420 int val4 ;
46421 int ecode4 = 0 ;
46422 int val5 ;
46423 int ecode5 = 0 ;
46424 PyObject * obj0 = 0 ;
46425 PyObject * obj1 = 0 ;
46426 PyObject * obj2 = 0 ;
46427 PyObject * obj3 = 0 ;
46428 PyObject * obj4 = 0 ;
46429 PyObject * obj5 = 0 ;
46430 char * kwnames[] = {
46431 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46432 };
46433
46434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46436 if (!SWIG_IsOK(res1)) {
46437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46438 }
46439 arg1 = reinterpret_cast< wxSizer * >(argp1);
46440 arg2 = obj1;
46441 if (obj2) {
46442 ecode3 = SWIG_AsVal_int(obj2, &val3);
46443 if (!SWIG_IsOK(ecode3)) {
46444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46445 }
46446 arg3 = static_cast< int >(val3);
46447 }
46448 if (obj3) {
46449 ecode4 = SWIG_AsVal_int(obj3, &val4);
46450 if (!SWIG_IsOK(ecode4)) {
46451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46452 }
46453 arg4 = static_cast< int >(val4);
46454 }
46455 if (obj4) {
46456 ecode5 = SWIG_AsVal_int(obj4, &val5);
46457 if (!SWIG_IsOK(ecode5)) {
46458 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46459 }
46460 arg5 = static_cast< int >(val5);
46461 }
46462 if (obj5) {
46463 arg6 = obj5;
46464 }
46465 {
46466 PyThreadState* __tstate = wxPyBeginAllowThreads();
46467 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46468 wxPyEndAllowThreads(__tstate);
46469 if (PyErr_Occurred()) SWIG_fail;
46470 }
46471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46472 return resultobj;
46473 fail:
46474 return NULL;
46475 }
46476
46477
46478 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46479 PyObject *resultobj = 0;
46480 wxSizer *arg1 = (wxSizer *) 0 ;
46481 int arg2 ;
46482 PyObject *arg3 = (PyObject *) 0 ;
46483 int arg4 = (int) 0 ;
46484 int arg5 = (int) 0 ;
46485 int arg6 = (int) 0 ;
46486 PyObject *arg7 = (PyObject *) NULL ;
46487 wxSizerItem *result = 0 ;
46488 void *argp1 = 0 ;
46489 int res1 = 0 ;
46490 int val2 ;
46491 int ecode2 = 0 ;
46492 int val4 ;
46493 int ecode4 = 0 ;
46494 int val5 ;
46495 int ecode5 = 0 ;
46496 int val6 ;
46497 int ecode6 = 0 ;
46498 PyObject * obj0 = 0 ;
46499 PyObject * obj1 = 0 ;
46500 PyObject * obj2 = 0 ;
46501 PyObject * obj3 = 0 ;
46502 PyObject * obj4 = 0 ;
46503 PyObject * obj5 = 0 ;
46504 PyObject * obj6 = 0 ;
46505 char * kwnames[] = {
46506 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46507 };
46508
46509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46511 if (!SWIG_IsOK(res1)) {
46512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46513 }
46514 arg1 = reinterpret_cast< wxSizer * >(argp1);
46515 ecode2 = SWIG_AsVal_int(obj1, &val2);
46516 if (!SWIG_IsOK(ecode2)) {
46517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46518 }
46519 arg2 = static_cast< int >(val2);
46520 arg3 = obj2;
46521 if (obj3) {
46522 ecode4 = SWIG_AsVal_int(obj3, &val4);
46523 if (!SWIG_IsOK(ecode4)) {
46524 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46525 }
46526 arg4 = static_cast< int >(val4);
46527 }
46528 if (obj4) {
46529 ecode5 = SWIG_AsVal_int(obj4, &val5);
46530 if (!SWIG_IsOK(ecode5)) {
46531 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46532 }
46533 arg5 = static_cast< int >(val5);
46534 }
46535 if (obj5) {
46536 ecode6 = SWIG_AsVal_int(obj5, &val6);
46537 if (!SWIG_IsOK(ecode6)) {
46538 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46539 }
46540 arg6 = static_cast< int >(val6);
46541 }
46542 if (obj6) {
46543 arg7 = obj6;
46544 }
46545 {
46546 PyThreadState* __tstate = wxPyBeginAllowThreads();
46547 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46548 wxPyEndAllowThreads(__tstate);
46549 if (PyErr_Occurred()) SWIG_fail;
46550 }
46551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46552 return resultobj;
46553 fail:
46554 return NULL;
46555 }
46556
46557
46558 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46559 PyObject *resultobj = 0;
46560 wxSizer *arg1 = (wxSizer *) 0 ;
46561 PyObject *arg2 = (PyObject *) 0 ;
46562 int arg3 = (int) 0 ;
46563 int arg4 = (int) 0 ;
46564 int arg5 = (int) 0 ;
46565 PyObject *arg6 = (PyObject *) NULL ;
46566 wxSizerItem *result = 0 ;
46567 void *argp1 = 0 ;
46568 int res1 = 0 ;
46569 int val3 ;
46570 int ecode3 = 0 ;
46571 int val4 ;
46572 int ecode4 = 0 ;
46573 int val5 ;
46574 int ecode5 = 0 ;
46575 PyObject * obj0 = 0 ;
46576 PyObject * obj1 = 0 ;
46577 PyObject * obj2 = 0 ;
46578 PyObject * obj3 = 0 ;
46579 PyObject * obj4 = 0 ;
46580 PyObject * obj5 = 0 ;
46581 char * kwnames[] = {
46582 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46583 };
46584
46585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46587 if (!SWIG_IsOK(res1)) {
46588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46589 }
46590 arg1 = reinterpret_cast< wxSizer * >(argp1);
46591 arg2 = obj1;
46592 if (obj2) {
46593 ecode3 = SWIG_AsVal_int(obj2, &val3);
46594 if (!SWIG_IsOK(ecode3)) {
46595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46596 }
46597 arg3 = static_cast< int >(val3);
46598 }
46599 if (obj3) {
46600 ecode4 = SWIG_AsVal_int(obj3, &val4);
46601 if (!SWIG_IsOK(ecode4)) {
46602 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46603 }
46604 arg4 = static_cast< int >(val4);
46605 }
46606 if (obj4) {
46607 ecode5 = SWIG_AsVal_int(obj4, &val5);
46608 if (!SWIG_IsOK(ecode5)) {
46609 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46610 }
46611 arg5 = static_cast< int >(val5);
46612 }
46613 if (obj5) {
46614 arg6 = obj5;
46615 }
46616 {
46617 PyThreadState* __tstate = wxPyBeginAllowThreads();
46618 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46619 wxPyEndAllowThreads(__tstate);
46620 if (PyErr_Occurred()) SWIG_fail;
46621 }
46622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46623 return resultobj;
46624 fail:
46625 return NULL;
46626 }
46627
46628
46629 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46630 PyObject *resultobj = 0;
46631 wxSizer *arg1 = (wxSizer *) 0 ;
46632 PyObject *arg2 = (PyObject *) 0 ;
46633 bool result;
46634 void *argp1 = 0 ;
46635 int res1 = 0 ;
46636 PyObject * obj0 = 0 ;
46637 PyObject * obj1 = 0 ;
46638 char * kwnames[] = {
46639 (char *) "self",(char *) "item", NULL
46640 };
46641
46642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46644 if (!SWIG_IsOK(res1)) {
46645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46646 }
46647 arg1 = reinterpret_cast< wxSizer * >(argp1);
46648 arg2 = obj1;
46649 {
46650 PyThreadState* __tstate = wxPyBeginAllowThreads();
46651 result = (bool)wxSizer_Remove(arg1,arg2);
46652 wxPyEndAllowThreads(__tstate);
46653 if (PyErr_Occurred()) SWIG_fail;
46654 }
46655 {
46656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46657 }
46658 return resultobj;
46659 fail:
46660 return NULL;
46661 }
46662
46663
46664 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46665 PyObject *resultobj = 0;
46666 wxSizer *arg1 = (wxSizer *) 0 ;
46667 PyObject *arg2 = (PyObject *) 0 ;
46668 bool result;
46669 void *argp1 = 0 ;
46670 int res1 = 0 ;
46671 PyObject * obj0 = 0 ;
46672 PyObject * obj1 = 0 ;
46673 char * kwnames[] = {
46674 (char *) "self",(char *) "item", NULL
46675 };
46676
46677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46679 if (!SWIG_IsOK(res1)) {
46680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46681 }
46682 arg1 = reinterpret_cast< wxSizer * >(argp1);
46683 arg2 = obj1;
46684 {
46685 PyThreadState* __tstate = wxPyBeginAllowThreads();
46686 result = (bool)wxSizer_Detach(arg1,arg2);
46687 wxPyEndAllowThreads(__tstate);
46688 if (PyErr_Occurred()) SWIG_fail;
46689 }
46690 {
46691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46692 }
46693 return resultobj;
46694 fail:
46695 return NULL;
46696 }
46697
46698
46699 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46700 PyObject *resultobj = 0;
46701 wxSizer *arg1 = (wxSizer *) 0 ;
46702 PyObject *arg2 = (PyObject *) 0 ;
46703 wxSizerItem *result = 0 ;
46704 void *argp1 = 0 ;
46705 int res1 = 0 ;
46706 PyObject * obj0 = 0 ;
46707 PyObject * obj1 = 0 ;
46708 char * kwnames[] = {
46709 (char *) "self",(char *) "item", NULL
46710 };
46711
46712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46714 if (!SWIG_IsOK(res1)) {
46715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46716 }
46717 arg1 = reinterpret_cast< wxSizer * >(argp1);
46718 arg2 = obj1;
46719 {
46720 PyThreadState* __tstate = wxPyBeginAllowThreads();
46721 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46722 wxPyEndAllowThreads(__tstate);
46723 if (PyErr_Occurred()) SWIG_fail;
46724 }
46725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46726 return resultobj;
46727 fail:
46728 return NULL;
46729 }
46730
46731
46732 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46733 PyObject *resultobj = 0;
46734 wxSizer *arg1 = (wxSizer *) 0 ;
46735 PyObject *arg2 = (PyObject *) 0 ;
46736 wxSize *arg3 = 0 ;
46737 void *argp1 = 0 ;
46738 int res1 = 0 ;
46739 wxSize temp3 ;
46740 PyObject * obj0 = 0 ;
46741 PyObject * obj1 = 0 ;
46742 PyObject * obj2 = 0 ;
46743 char * kwnames[] = {
46744 (char *) "self",(char *) "item",(char *) "size", NULL
46745 };
46746
46747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46749 if (!SWIG_IsOK(res1)) {
46750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46751 }
46752 arg1 = reinterpret_cast< wxSizer * >(argp1);
46753 arg2 = obj1;
46754 {
46755 arg3 = &temp3;
46756 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46757 }
46758 {
46759 PyThreadState* __tstate = wxPyBeginAllowThreads();
46760 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46761 wxPyEndAllowThreads(__tstate);
46762 if (PyErr_Occurred()) SWIG_fail;
46763 }
46764 resultobj = SWIG_Py_Void();
46765 return resultobj;
46766 fail:
46767 return NULL;
46768 }
46769
46770
46771 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46772 PyObject *resultobj = 0;
46773 wxSizer *arg1 = (wxSizer *) 0 ;
46774 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46775 wxSizerItem *result = 0 ;
46776 void *argp1 = 0 ;
46777 int res1 = 0 ;
46778 int res2 = 0 ;
46779 PyObject * obj0 = 0 ;
46780 PyObject * obj1 = 0 ;
46781 char * kwnames[] = {
46782 (char *) "self",(char *) "item", NULL
46783 };
46784
46785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46787 if (!SWIG_IsOK(res1)) {
46788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46789 }
46790 arg1 = reinterpret_cast< wxSizer * >(argp1);
46791 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46792 if (!SWIG_IsOK(res2)) {
46793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46794 }
46795 {
46796 PyThreadState* __tstate = wxPyBeginAllowThreads();
46797 result = (wxSizerItem *)(arg1)->Add(arg2);
46798 wxPyEndAllowThreads(__tstate);
46799 if (PyErr_Occurred()) SWIG_fail;
46800 }
46801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46802 return resultobj;
46803 fail:
46804 return NULL;
46805 }
46806
46807
46808 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46809 PyObject *resultobj = 0;
46810 wxSizer *arg1 = (wxSizer *) 0 ;
46811 size_t arg2 ;
46812 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46813 wxSizerItem *result = 0 ;
46814 void *argp1 = 0 ;
46815 int res1 = 0 ;
46816 size_t val2 ;
46817 int ecode2 = 0 ;
46818 int res3 = 0 ;
46819 PyObject * obj0 = 0 ;
46820 PyObject * obj1 = 0 ;
46821 PyObject * obj2 = 0 ;
46822 char * kwnames[] = {
46823 (char *) "self",(char *) "index",(char *) "item", NULL
46824 };
46825
46826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46828 if (!SWIG_IsOK(res1)) {
46829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46830 }
46831 arg1 = reinterpret_cast< wxSizer * >(argp1);
46832 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46833 if (!SWIG_IsOK(ecode2)) {
46834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46835 }
46836 arg2 = static_cast< size_t >(val2);
46837 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46838 if (!SWIG_IsOK(res3)) {
46839 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46840 }
46841 {
46842 PyThreadState* __tstate = wxPyBeginAllowThreads();
46843 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46844 wxPyEndAllowThreads(__tstate);
46845 if (PyErr_Occurred()) SWIG_fail;
46846 }
46847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46848 return resultobj;
46849 fail:
46850 return NULL;
46851 }
46852
46853
46854 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46855 PyObject *resultobj = 0;
46856 wxSizer *arg1 = (wxSizer *) 0 ;
46857 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46858 wxSizerItem *result = 0 ;
46859 void *argp1 = 0 ;
46860 int res1 = 0 ;
46861 int res2 = 0 ;
46862 PyObject * obj0 = 0 ;
46863 PyObject * obj1 = 0 ;
46864 char * kwnames[] = {
46865 (char *) "self",(char *) "item", NULL
46866 };
46867
46868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46870 if (!SWIG_IsOK(res1)) {
46871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46872 }
46873 arg1 = reinterpret_cast< wxSizer * >(argp1);
46874 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46875 if (!SWIG_IsOK(res2)) {
46876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46877 }
46878 {
46879 PyThreadState* __tstate = wxPyBeginAllowThreads();
46880 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46881 wxPyEndAllowThreads(__tstate);
46882 if (PyErr_Occurred()) SWIG_fail;
46883 }
46884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46885 return resultobj;
46886 fail:
46887 return NULL;
46888 }
46889
46890
46891 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46892 PyObject *resultobj = 0;
46893 wxSizer *arg1 = (wxSizer *) 0 ;
46894 int arg2 ;
46895 int arg3 ;
46896 int arg4 ;
46897 int arg5 ;
46898 void *argp1 = 0 ;
46899 int res1 = 0 ;
46900 int val2 ;
46901 int ecode2 = 0 ;
46902 int val3 ;
46903 int ecode3 = 0 ;
46904 int val4 ;
46905 int ecode4 = 0 ;
46906 int val5 ;
46907 int ecode5 = 0 ;
46908 PyObject * obj0 = 0 ;
46909 PyObject * obj1 = 0 ;
46910 PyObject * obj2 = 0 ;
46911 PyObject * obj3 = 0 ;
46912 PyObject * obj4 = 0 ;
46913 char * kwnames[] = {
46914 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46915 };
46916
46917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46919 if (!SWIG_IsOK(res1)) {
46920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46921 }
46922 arg1 = reinterpret_cast< wxSizer * >(argp1);
46923 ecode2 = SWIG_AsVal_int(obj1, &val2);
46924 if (!SWIG_IsOK(ecode2)) {
46925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46926 }
46927 arg2 = static_cast< int >(val2);
46928 ecode3 = SWIG_AsVal_int(obj2, &val3);
46929 if (!SWIG_IsOK(ecode3)) {
46930 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46931 }
46932 arg3 = static_cast< int >(val3);
46933 ecode4 = SWIG_AsVal_int(obj3, &val4);
46934 if (!SWIG_IsOK(ecode4)) {
46935 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46936 }
46937 arg4 = static_cast< int >(val4);
46938 ecode5 = SWIG_AsVal_int(obj4, &val5);
46939 if (!SWIG_IsOK(ecode5)) {
46940 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46941 }
46942 arg5 = static_cast< int >(val5);
46943 {
46944 PyThreadState* __tstate = wxPyBeginAllowThreads();
46945 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46946 wxPyEndAllowThreads(__tstate);
46947 if (PyErr_Occurred()) SWIG_fail;
46948 }
46949 resultobj = SWIG_Py_Void();
46950 return resultobj;
46951 fail:
46952 return NULL;
46953 }
46954
46955
46956 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46957 PyObject *resultobj = 0;
46958 wxSizer *arg1 = (wxSizer *) 0 ;
46959 wxSize *arg2 = 0 ;
46960 void *argp1 = 0 ;
46961 int res1 = 0 ;
46962 wxSize temp2 ;
46963 PyObject * obj0 = 0 ;
46964 PyObject * obj1 = 0 ;
46965 char * kwnames[] = {
46966 (char *) "self",(char *) "size", NULL
46967 };
46968
46969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46971 if (!SWIG_IsOK(res1)) {
46972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46973 }
46974 arg1 = reinterpret_cast< wxSizer * >(argp1);
46975 {
46976 arg2 = &temp2;
46977 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46978 }
46979 {
46980 PyThreadState* __tstate = wxPyBeginAllowThreads();
46981 (arg1)->SetMinSize((wxSize const &)*arg2);
46982 wxPyEndAllowThreads(__tstate);
46983 if (PyErr_Occurred()) SWIG_fail;
46984 }
46985 resultobj = SWIG_Py_Void();
46986 return resultobj;
46987 fail:
46988 return NULL;
46989 }
46990
46991
46992 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46993 PyObject *resultobj = 0;
46994 wxSizer *arg1 = (wxSizer *) 0 ;
46995 wxSize result;
46996 void *argp1 = 0 ;
46997 int res1 = 0 ;
46998 PyObject *swig_obj[1] ;
46999
47000 if (!args) SWIG_fail;
47001 swig_obj[0] = args;
47002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47003 if (!SWIG_IsOK(res1)) {
47004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47005 }
47006 arg1 = reinterpret_cast< wxSizer * >(argp1);
47007 {
47008 PyThreadState* __tstate = wxPyBeginAllowThreads();
47009 result = (arg1)->GetSize();
47010 wxPyEndAllowThreads(__tstate);
47011 if (PyErr_Occurred()) SWIG_fail;
47012 }
47013 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47014 return resultobj;
47015 fail:
47016 return NULL;
47017 }
47018
47019
47020 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47021 PyObject *resultobj = 0;
47022 wxSizer *arg1 = (wxSizer *) 0 ;
47023 wxPoint result;
47024 void *argp1 = 0 ;
47025 int res1 = 0 ;
47026 PyObject *swig_obj[1] ;
47027
47028 if (!args) SWIG_fail;
47029 swig_obj[0] = args;
47030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47031 if (!SWIG_IsOK(res1)) {
47032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47033 }
47034 arg1 = reinterpret_cast< wxSizer * >(argp1);
47035 {
47036 PyThreadState* __tstate = wxPyBeginAllowThreads();
47037 result = (arg1)->GetPosition();
47038 wxPyEndAllowThreads(__tstate);
47039 if (PyErr_Occurred()) SWIG_fail;
47040 }
47041 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47042 return resultobj;
47043 fail:
47044 return NULL;
47045 }
47046
47047
47048 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47049 PyObject *resultobj = 0;
47050 wxSizer *arg1 = (wxSizer *) 0 ;
47051 wxSize result;
47052 void *argp1 = 0 ;
47053 int res1 = 0 ;
47054 PyObject *swig_obj[1] ;
47055
47056 if (!args) SWIG_fail;
47057 swig_obj[0] = args;
47058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47059 if (!SWIG_IsOK(res1)) {
47060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47061 }
47062 arg1 = reinterpret_cast< wxSizer * >(argp1);
47063 {
47064 PyThreadState* __tstate = wxPyBeginAllowThreads();
47065 result = (arg1)->GetMinSize();
47066 wxPyEndAllowThreads(__tstate);
47067 if (PyErr_Occurred()) SWIG_fail;
47068 }
47069 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47070 return resultobj;
47071 fail:
47072 return NULL;
47073 }
47074
47075
47076 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47077 PyObject *resultobj = 0;
47078 wxSizer *arg1 = (wxSizer *) 0 ;
47079 void *argp1 = 0 ;
47080 int res1 = 0 ;
47081 PyObject *swig_obj[1] ;
47082
47083 if (!args) SWIG_fail;
47084 swig_obj[0] = args;
47085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47086 if (!SWIG_IsOK(res1)) {
47087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47088 }
47089 arg1 = reinterpret_cast< wxSizer * >(argp1);
47090 {
47091 PyThreadState* __tstate = wxPyBeginAllowThreads();
47092 (arg1)->RecalcSizes();
47093 wxPyEndAllowThreads(__tstate);
47094 if (PyErr_Occurred()) SWIG_fail;
47095 }
47096 resultobj = SWIG_Py_Void();
47097 return resultobj;
47098 fail:
47099 return NULL;
47100 }
47101
47102
47103 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47104 PyObject *resultobj = 0;
47105 wxSizer *arg1 = (wxSizer *) 0 ;
47106 wxSize result;
47107 void *argp1 = 0 ;
47108 int res1 = 0 ;
47109 PyObject *swig_obj[1] ;
47110
47111 if (!args) SWIG_fail;
47112 swig_obj[0] = args;
47113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47114 if (!SWIG_IsOK(res1)) {
47115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47116 }
47117 arg1 = reinterpret_cast< wxSizer * >(argp1);
47118 {
47119 PyThreadState* __tstate = wxPyBeginAllowThreads();
47120 result = (arg1)->CalcMin();
47121 wxPyEndAllowThreads(__tstate);
47122 if (PyErr_Occurred()) SWIG_fail;
47123 }
47124 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47125 return resultobj;
47126 fail:
47127 return NULL;
47128 }
47129
47130
47131 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47132 PyObject *resultobj = 0;
47133 wxSizer *arg1 = (wxSizer *) 0 ;
47134 void *argp1 = 0 ;
47135 int res1 = 0 ;
47136 PyObject *swig_obj[1] ;
47137
47138 if (!args) SWIG_fail;
47139 swig_obj[0] = args;
47140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47141 if (!SWIG_IsOK(res1)) {
47142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47143 }
47144 arg1 = reinterpret_cast< wxSizer * >(argp1);
47145 {
47146 PyThreadState* __tstate = wxPyBeginAllowThreads();
47147 (arg1)->Layout();
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_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47159 PyObject *resultobj = 0;
47160 wxSizer *arg1 = (wxSizer *) 0 ;
47161 wxWindow *arg2 = (wxWindow *) 0 ;
47162 wxSize result;
47163 void *argp1 = 0 ;
47164 int res1 = 0 ;
47165 void *argp2 = 0 ;
47166 int res2 = 0 ;
47167 PyObject * obj0 = 0 ;
47168 PyObject * obj1 = 0 ;
47169 char * kwnames[] = {
47170 (char *) "self",(char *) "window", NULL
47171 };
47172
47173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47175 if (!SWIG_IsOK(res1)) {
47176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47177 }
47178 arg1 = reinterpret_cast< wxSizer * >(argp1);
47179 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47180 if (!SWIG_IsOK(res2)) {
47181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47182 }
47183 arg2 = reinterpret_cast< wxWindow * >(argp2);
47184 {
47185 PyThreadState* __tstate = wxPyBeginAllowThreads();
47186 result = (arg1)->Fit(arg2);
47187 wxPyEndAllowThreads(__tstate);
47188 if (PyErr_Occurred()) SWIG_fail;
47189 }
47190 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47191 return resultobj;
47192 fail:
47193 return NULL;
47194 }
47195
47196
47197 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47198 PyObject *resultobj = 0;
47199 wxSizer *arg1 = (wxSizer *) 0 ;
47200 wxWindow *arg2 = (wxWindow *) 0 ;
47201 void *argp1 = 0 ;
47202 int res1 = 0 ;
47203 void *argp2 = 0 ;
47204 int res2 = 0 ;
47205 PyObject * obj0 = 0 ;
47206 PyObject * obj1 = 0 ;
47207 char * kwnames[] = {
47208 (char *) "self",(char *) "window", NULL
47209 };
47210
47211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47213 if (!SWIG_IsOK(res1)) {
47214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47215 }
47216 arg1 = reinterpret_cast< wxSizer * >(argp1);
47217 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47218 if (!SWIG_IsOK(res2)) {
47219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47220 }
47221 arg2 = reinterpret_cast< wxWindow * >(argp2);
47222 {
47223 PyThreadState* __tstate = wxPyBeginAllowThreads();
47224 (arg1)->FitInside(arg2);
47225 wxPyEndAllowThreads(__tstate);
47226 if (PyErr_Occurred()) SWIG_fail;
47227 }
47228 resultobj = SWIG_Py_Void();
47229 return resultobj;
47230 fail:
47231 return NULL;
47232 }
47233
47234
47235 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47236 PyObject *resultobj = 0;
47237 wxSizer *arg1 = (wxSizer *) 0 ;
47238 wxWindow *arg2 = (wxWindow *) 0 ;
47239 void *argp1 = 0 ;
47240 int res1 = 0 ;
47241 void *argp2 = 0 ;
47242 int res2 = 0 ;
47243 PyObject * obj0 = 0 ;
47244 PyObject * obj1 = 0 ;
47245 char * kwnames[] = {
47246 (char *) "self",(char *) "window", NULL
47247 };
47248
47249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47251 if (!SWIG_IsOK(res1)) {
47252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47253 }
47254 arg1 = reinterpret_cast< wxSizer * >(argp1);
47255 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47256 if (!SWIG_IsOK(res2)) {
47257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47258 }
47259 arg2 = reinterpret_cast< wxWindow * >(argp2);
47260 {
47261 PyThreadState* __tstate = wxPyBeginAllowThreads();
47262 (arg1)->SetSizeHints(arg2);
47263 wxPyEndAllowThreads(__tstate);
47264 if (PyErr_Occurred()) SWIG_fail;
47265 }
47266 resultobj = SWIG_Py_Void();
47267 return resultobj;
47268 fail:
47269 return NULL;
47270 }
47271
47272
47273 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47274 PyObject *resultobj = 0;
47275 wxSizer *arg1 = (wxSizer *) 0 ;
47276 wxWindow *arg2 = (wxWindow *) 0 ;
47277 void *argp1 = 0 ;
47278 int res1 = 0 ;
47279 void *argp2 = 0 ;
47280 int res2 = 0 ;
47281 PyObject * obj0 = 0 ;
47282 PyObject * obj1 = 0 ;
47283 char * kwnames[] = {
47284 (char *) "self",(char *) "window", NULL
47285 };
47286
47287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47289 if (!SWIG_IsOK(res1)) {
47290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47291 }
47292 arg1 = reinterpret_cast< wxSizer * >(argp1);
47293 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47294 if (!SWIG_IsOK(res2)) {
47295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47296 }
47297 arg2 = reinterpret_cast< wxWindow * >(argp2);
47298 {
47299 PyThreadState* __tstate = wxPyBeginAllowThreads();
47300 (arg1)->SetVirtualSizeHints(arg2);
47301 wxPyEndAllowThreads(__tstate);
47302 if (PyErr_Occurred()) SWIG_fail;
47303 }
47304 resultobj = SWIG_Py_Void();
47305 return resultobj;
47306 fail:
47307 return NULL;
47308 }
47309
47310
47311 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47312 PyObject *resultobj = 0;
47313 wxSizer *arg1 = (wxSizer *) 0 ;
47314 bool arg2 = (bool) false ;
47315 void *argp1 = 0 ;
47316 int res1 = 0 ;
47317 bool val2 ;
47318 int ecode2 = 0 ;
47319 PyObject * obj0 = 0 ;
47320 PyObject * obj1 = 0 ;
47321 char * kwnames[] = {
47322 (char *) "self",(char *) "deleteWindows", NULL
47323 };
47324
47325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47327 if (!SWIG_IsOK(res1)) {
47328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47329 }
47330 arg1 = reinterpret_cast< wxSizer * >(argp1);
47331 if (obj1) {
47332 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47333 if (!SWIG_IsOK(ecode2)) {
47334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47335 }
47336 arg2 = static_cast< bool >(val2);
47337 }
47338 {
47339 PyThreadState* __tstate = wxPyBeginAllowThreads();
47340 (arg1)->Clear(arg2);
47341 wxPyEndAllowThreads(__tstate);
47342 if (PyErr_Occurred()) SWIG_fail;
47343 }
47344 resultobj = SWIG_Py_Void();
47345 return resultobj;
47346 fail:
47347 return NULL;
47348 }
47349
47350
47351 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47352 PyObject *resultobj = 0;
47353 wxSizer *arg1 = (wxSizer *) 0 ;
47354 void *argp1 = 0 ;
47355 int res1 = 0 ;
47356 PyObject *swig_obj[1] ;
47357
47358 if (!args) SWIG_fail;
47359 swig_obj[0] = args;
47360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47361 if (!SWIG_IsOK(res1)) {
47362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47363 }
47364 arg1 = reinterpret_cast< wxSizer * >(argp1);
47365 {
47366 PyThreadState* __tstate = wxPyBeginAllowThreads();
47367 (arg1)->DeleteWindows();
47368 wxPyEndAllowThreads(__tstate);
47369 if (PyErr_Occurred()) SWIG_fail;
47370 }
47371 resultobj = SWIG_Py_Void();
47372 return resultobj;
47373 fail:
47374 return NULL;
47375 }
47376
47377
47378 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47379 PyObject *resultobj = 0;
47380 wxSizer *arg1 = (wxSizer *) 0 ;
47381 PyObject *result = 0 ;
47382 void *argp1 = 0 ;
47383 int res1 = 0 ;
47384 PyObject *swig_obj[1] ;
47385
47386 if (!args) SWIG_fail;
47387 swig_obj[0] = args;
47388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47389 if (!SWIG_IsOK(res1)) {
47390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47391 }
47392 arg1 = reinterpret_cast< wxSizer * >(argp1);
47393 {
47394 PyThreadState* __tstate = wxPyBeginAllowThreads();
47395 result = (PyObject *)wxSizer_GetChildren(arg1);
47396 wxPyEndAllowThreads(__tstate);
47397 if (PyErr_Occurred()) SWIG_fail;
47398 }
47399 resultobj = result;
47400 return resultobj;
47401 fail:
47402 return NULL;
47403 }
47404
47405
47406 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47407 PyObject *resultobj = 0;
47408 wxSizer *arg1 = (wxSizer *) 0 ;
47409 PyObject *arg2 = (PyObject *) 0 ;
47410 bool arg3 = (bool) true ;
47411 bool arg4 = (bool) false ;
47412 bool result;
47413 void *argp1 = 0 ;
47414 int res1 = 0 ;
47415 bool val3 ;
47416 int ecode3 = 0 ;
47417 bool val4 ;
47418 int ecode4 = 0 ;
47419 PyObject * obj0 = 0 ;
47420 PyObject * obj1 = 0 ;
47421 PyObject * obj2 = 0 ;
47422 PyObject * obj3 = 0 ;
47423 char * kwnames[] = {
47424 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47425 };
47426
47427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47429 if (!SWIG_IsOK(res1)) {
47430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47431 }
47432 arg1 = reinterpret_cast< wxSizer * >(argp1);
47433 arg2 = obj1;
47434 if (obj2) {
47435 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47436 if (!SWIG_IsOK(ecode3)) {
47437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47438 }
47439 arg3 = static_cast< bool >(val3);
47440 }
47441 if (obj3) {
47442 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47443 if (!SWIG_IsOK(ecode4)) {
47444 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47445 }
47446 arg4 = static_cast< bool >(val4);
47447 }
47448 {
47449 PyThreadState* __tstate = wxPyBeginAllowThreads();
47450 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47451 wxPyEndAllowThreads(__tstate);
47452 if (PyErr_Occurred()) SWIG_fail;
47453 }
47454 {
47455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47456 }
47457 return resultobj;
47458 fail:
47459 return NULL;
47460 }
47461
47462
47463 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47464 PyObject *resultobj = 0;
47465 wxSizer *arg1 = (wxSizer *) 0 ;
47466 PyObject *arg2 = (PyObject *) 0 ;
47467 bool result;
47468 void *argp1 = 0 ;
47469 int res1 = 0 ;
47470 PyObject * obj0 = 0 ;
47471 PyObject * obj1 = 0 ;
47472 char * kwnames[] = {
47473 (char *) "self",(char *) "item", NULL
47474 };
47475
47476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47478 if (!SWIG_IsOK(res1)) {
47479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47480 }
47481 arg1 = reinterpret_cast< wxSizer * >(argp1);
47482 arg2 = obj1;
47483 {
47484 PyThreadState* __tstate = wxPyBeginAllowThreads();
47485 result = (bool)wxSizer_IsShown(arg1,arg2);
47486 wxPyEndAllowThreads(__tstate);
47487 if (PyErr_Occurred()) SWIG_fail;
47488 }
47489 {
47490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47491 }
47492 return resultobj;
47493 fail:
47494 return NULL;
47495 }
47496
47497
47498 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47499 PyObject *resultobj = 0;
47500 wxSizer *arg1 = (wxSizer *) 0 ;
47501 bool arg2 ;
47502 void *argp1 = 0 ;
47503 int res1 = 0 ;
47504 bool val2 ;
47505 int ecode2 = 0 ;
47506 PyObject * obj0 = 0 ;
47507 PyObject * obj1 = 0 ;
47508 char * kwnames[] = {
47509 (char *) "self",(char *) "show", NULL
47510 };
47511
47512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47514 if (!SWIG_IsOK(res1)) {
47515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47516 }
47517 arg1 = reinterpret_cast< wxSizer * >(argp1);
47518 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47519 if (!SWIG_IsOK(ecode2)) {
47520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47521 }
47522 arg2 = static_cast< bool >(val2);
47523 {
47524 PyThreadState* __tstate = wxPyBeginAllowThreads();
47525 (arg1)->ShowItems(arg2);
47526 wxPyEndAllowThreads(__tstate);
47527 if (PyErr_Occurred()) SWIG_fail;
47528 }
47529 resultobj = SWIG_Py_Void();
47530 return resultobj;
47531 fail:
47532 return NULL;
47533 }
47534
47535
47536 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47537 PyObject *obj;
47538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47539 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47540 return SWIG_Py_Void();
47541 }
47542
47543 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47544 PyObject *resultobj = 0;
47545 wxPySizer *result = 0 ;
47546
47547 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47548 {
47549 PyThreadState* __tstate = wxPyBeginAllowThreads();
47550 result = (wxPySizer *)new wxPySizer();
47551 wxPyEndAllowThreads(__tstate);
47552 if (PyErr_Occurred()) SWIG_fail;
47553 }
47554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47555 return resultobj;
47556 fail:
47557 return NULL;
47558 }
47559
47560
47561 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47562 PyObject *resultobj = 0;
47563 wxPySizer *arg1 = (wxPySizer *) 0 ;
47564 PyObject *arg2 = (PyObject *) 0 ;
47565 PyObject *arg3 = (PyObject *) 0 ;
47566 void *argp1 = 0 ;
47567 int res1 = 0 ;
47568 PyObject * obj0 = 0 ;
47569 PyObject * obj1 = 0 ;
47570 PyObject * obj2 = 0 ;
47571 char * kwnames[] = {
47572 (char *) "self",(char *) "self",(char *) "_class", NULL
47573 };
47574
47575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47577 if (!SWIG_IsOK(res1)) {
47578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47579 }
47580 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47581 arg2 = obj1;
47582 arg3 = obj2;
47583 {
47584 PyThreadState* __tstate = wxPyBeginAllowThreads();
47585 (arg1)->_setCallbackInfo(arg2,arg3);
47586 wxPyEndAllowThreads(__tstate);
47587 if (PyErr_Occurred()) SWIG_fail;
47588 }
47589 resultobj = SWIG_Py_Void();
47590 return resultobj;
47591 fail:
47592 return NULL;
47593 }
47594
47595
47596 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47597 PyObject *obj;
47598 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47599 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47600 return SWIG_Py_Void();
47601 }
47602
47603 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47604 return SWIG_Python_InitShadowInstance(args);
47605 }
47606
47607 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47608 PyObject *resultobj = 0;
47609 int arg1 = (int) wxHORIZONTAL ;
47610 wxBoxSizer *result = 0 ;
47611 int val1 ;
47612 int ecode1 = 0 ;
47613 PyObject * obj0 = 0 ;
47614 char * kwnames[] = {
47615 (char *) "orient", NULL
47616 };
47617
47618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47619 if (obj0) {
47620 ecode1 = SWIG_AsVal_int(obj0, &val1);
47621 if (!SWIG_IsOK(ecode1)) {
47622 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47623 }
47624 arg1 = static_cast< int >(val1);
47625 }
47626 {
47627 PyThreadState* __tstate = wxPyBeginAllowThreads();
47628 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47629 wxPyEndAllowThreads(__tstate);
47630 if (PyErr_Occurred()) SWIG_fail;
47631 }
47632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47633 return resultobj;
47634 fail:
47635 return NULL;
47636 }
47637
47638
47639 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47640 PyObject *resultobj = 0;
47641 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47642 int result;
47643 void *argp1 = 0 ;
47644 int res1 = 0 ;
47645 PyObject *swig_obj[1] ;
47646
47647 if (!args) SWIG_fail;
47648 swig_obj[0] = args;
47649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47650 if (!SWIG_IsOK(res1)) {
47651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47652 }
47653 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47654 {
47655 PyThreadState* __tstate = wxPyBeginAllowThreads();
47656 result = (int)(arg1)->GetOrientation();
47657 wxPyEndAllowThreads(__tstate);
47658 if (PyErr_Occurred()) SWIG_fail;
47659 }
47660 resultobj = SWIG_From_int(static_cast< int >(result));
47661 return resultobj;
47662 fail:
47663 return NULL;
47664 }
47665
47666
47667 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47668 PyObject *resultobj = 0;
47669 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47670 int arg2 ;
47671 void *argp1 = 0 ;
47672 int res1 = 0 ;
47673 int val2 ;
47674 int ecode2 = 0 ;
47675 PyObject * obj0 = 0 ;
47676 PyObject * obj1 = 0 ;
47677 char * kwnames[] = {
47678 (char *) "self",(char *) "orient", NULL
47679 };
47680
47681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47683 if (!SWIG_IsOK(res1)) {
47684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47685 }
47686 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47687 ecode2 = SWIG_AsVal_int(obj1, &val2);
47688 if (!SWIG_IsOK(ecode2)) {
47689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47690 }
47691 arg2 = static_cast< int >(val2);
47692 {
47693 PyThreadState* __tstate = wxPyBeginAllowThreads();
47694 (arg1)->SetOrientation(arg2);
47695 wxPyEndAllowThreads(__tstate);
47696 if (PyErr_Occurred()) SWIG_fail;
47697 }
47698 resultobj = SWIG_Py_Void();
47699 return resultobj;
47700 fail:
47701 return NULL;
47702 }
47703
47704
47705 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47706 PyObject *obj;
47707 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47708 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47709 return SWIG_Py_Void();
47710 }
47711
47712 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47713 return SWIG_Python_InitShadowInstance(args);
47714 }
47715
47716 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47717 PyObject *resultobj = 0;
47718 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47719 int arg2 = (int) wxHORIZONTAL ;
47720 wxStaticBoxSizer *result = 0 ;
47721 void *argp1 = 0 ;
47722 int res1 = 0 ;
47723 int val2 ;
47724 int ecode2 = 0 ;
47725 PyObject * obj0 = 0 ;
47726 PyObject * obj1 = 0 ;
47727 char * kwnames[] = {
47728 (char *) "box",(char *) "orient", NULL
47729 };
47730
47731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47733 if (!SWIG_IsOK(res1)) {
47734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47735 }
47736 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47737 if (obj1) {
47738 ecode2 = SWIG_AsVal_int(obj1, &val2);
47739 if (!SWIG_IsOK(ecode2)) {
47740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47741 }
47742 arg2 = static_cast< int >(val2);
47743 }
47744 {
47745 PyThreadState* __tstate = wxPyBeginAllowThreads();
47746 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47747 wxPyEndAllowThreads(__tstate);
47748 if (PyErr_Occurred()) SWIG_fail;
47749 }
47750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47751 return resultobj;
47752 fail:
47753 return NULL;
47754 }
47755
47756
47757 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47758 PyObject *resultobj = 0;
47759 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47760 wxStaticBox *result = 0 ;
47761 void *argp1 = 0 ;
47762 int res1 = 0 ;
47763 PyObject *swig_obj[1] ;
47764
47765 if (!args) SWIG_fail;
47766 swig_obj[0] = args;
47767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47768 if (!SWIG_IsOK(res1)) {
47769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47770 }
47771 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47772 {
47773 PyThreadState* __tstate = wxPyBeginAllowThreads();
47774 result = (wxStaticBox *)(arg1)->GetStaticBox();
47775 wxPyEndAllowThreads(__tstate);
47776 if (PyErr_Occurred()) SWIG_fail;
47777 }
47778 {
47779 resultobj = wxPyMake_wxObject(result, (bool)0);
47780 }
47781 return resultobj;
47782 fail:
47783 return NULL;
47784 }
47785
47786
47787 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47788 PyObject *obj;
47789 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47790 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47791 return SWIG_Py_Void();
47792 }
47793
47794 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47795 return SWIG_Python_InitShadowInstance(args);
47796 }
47797
47798 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47799 PyObject *resultobj = 0;
47800 int arg1 = (int) 1 ;
47801 int arg2 = (int) 0 ;
47802 int arg3 = (int) 0 ;
47803 int arg4 = (int) 0 ;
47804 wxGridSizer *result = 0 ;
47805 int val1 ;
47806 int ecode1 = 0 ;
47807 int val2 ;
47808 int ecode2 = 0 ;
47809 int val3 ;
47810 int ecode3 = 0 ;
47811 int val4 ;
47812 int ecode4 = 0 ;
47813 PyObject * obj0 = 0 ;
47814 PyObject * obj1 = 0 ;
47815 PyObject * obj2 = 0 ;
47816 PyObject * obj3 = 0 ;
47817 char * kwnames[] = {
47818 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47819 };
47820
47821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47822 if (obj0) {
47823 ecode1 = SWIG_AsVal_int(obj0, &val1);
47824 if (!SWIG_IsOK(ecode1)) {
47825 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47826 }
47827 arg1 = static_cast< int >(val1);
47828 }
47829 if (obj1) {
47830 ecode2 = SWIG_AsVal_int(obj1, &val2);
47831 if (!SWIG_IsOK(ecode2)) {
47832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47833 }
47834 arg2 = static_cast< int >(val2);
47835 }
47836 if (obj2) {
47837 ecode3 = SWIG_AsVal_int(obj2, &val3);
47838 if (!SWIG_IsOK(ecode3)) {
47839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47840 }
47841 arg3 = static_cast< int >(val3);
47842 }
47843 if (obj3) {
47844 ecode4 = SWIG_AsVal_int(obj3, &val4);
47845 if (!SWIG_IsOK(ecode4)) {
47846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47847 }
47848 arg4 = static_cast< int >(val4);
47849 }
47850 {
47851 PyThreadState* __tstate = wxPyBeginAllowThreads();
47852 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47853 wxPyEndAllowThreads(__tstate);
47854 if (PyErr_Occurred()) SWIG_fail;
47855 }
47856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47857 return resultobj;
47858 fail:
47859 return NULL;
47860 }
47861
47862
47863 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47864 PyObject *resultobj = 0;
47865 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47866 int arg2 ;
47867 void *argp1 = 0 ;
47868 int res1 = 0 ;
47869 int val2 ;
47870 int ecode2 = 0 ;
47871 PyObject * obj0 = 0 ;
47872 PyObject * obj1 = 0 ;
47873 char * kwnames[] = {
47874 (char *) "self",(char *) "cols", NULL
47875 };
47876
47877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47879 if (!SWIG_IsOK(res1)) {
47880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47881 }
47882 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47883 ecode2 = SWIG_AsVal_int(obj1, &val2);
47884 if (!SWIG_IsOK(ecode2)) {
47885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47886 }
47887 arg2 = static_cast< int >(val2);
47888 {
47889 PyThreadState* __tstate = wxPyBeginAllowThreads();
47890 (arg1)->SetCols(arg2);
47891 wxPyEndAllowThreads(__tstate);
47892 if (PyErr_Occurred()) SWIG_fail;
47893 }
47894 resultobj = SWIG_Py_Void();
47895 return resultobj;
47896 fail:
47897 return NULL;
47898 }
47899
47900
47901 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47902 PyObject *resultobj = 0;
47903 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47904 int arg2 ;
47905 void *argp1 = 0 ;
47906 int res1 = 0 ;
47907 int val2 ;
47908 int ecode2 = 0 ;
47909 PyObject * obj0 = 0 ;
47910 PyObject * obj1 = 0 ;
47911 char * kwnames[] = {
47912 (char *) "self",(char *) "rows", NULL
47913 };
47914
47915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47917 if (!SWIG_IsOK(res1)) {
47918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47919 }
47920 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47921 ecode2 = SWIG_AsVal_int(obj1, &val2);
47922 if (!SWIG_IsOK(ecode2)) {
47923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47924 }
47925 arg2 = static_cast< int >(val2);
47926 {
47927 PyThreadState* __tstate = wxPyBeginAllowThreads();
47928 (arg1)->SetRows(arg2);
47929 wxPyEndAllowThreads(__tstate);
47930 if (PyErr_Occurred()) SWIG_fail;
47931 }
47932 resultobj = SWIG_Py_Void();
47933 return resultobj;
47934 fail:
47935 return NULL;
47936 }
47937
47938
47939 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47940 PyObject *resultobj = 0;
47941 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47942 int arg2 ;
47943 void *argp1 = 0 ;
47944 int res1 = 0 ;
47945 int val2 ;
47946 int ecode2 = 0 ;
47947 PyObject * obj0 = 0 ;
47948 PyObject * obj1 = 0 ;
47949 char * kwnames[] = {
47950 (char *) "self",(char *) "gap", NULL
47951 };
47952
47953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47955 if (!SWIG_IsOK(res1)) {
47956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47957 }
47958 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47959 ecode2 = SWIG_AsVal_int(obj1, &val2);
47960 if (!SWIG_IsOK(ecode2)) {
47961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47962 }
47963 arg2 = static_cast< int >(val2);
47964 {
47965 PyThreadState* __tstate = wxPyBeginAllowThreads();
47966 (arg1)->SetVGap(arg2);
47967 wxPyEndAllowThreads(__tstate);
47968 if (PyErr_Occurred()) SWIG_fail;
47969 }
47970 resultobj = SWIG_Py_Void();
47971 return resultobj;
47972 fail:
47973 return NULL;
47974 }
47975
47976
47977 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47978 PyObject *resultobj = 0;
47979 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47980 int arg2 ;
47981 void *argp1 = 0 ;
47982 int res1 = 0 ;
47983 int val2 ;
47984 int ecode2 = 0 ;
47985 PyObject * obj0 = 0 ;
47986 PyObject * obj1 = 0 ;
47987 char * kwnames[] = {
47988 (char *) "self",(char *) "gap", NULL
47989 };
47990
47991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47993 if (!SWIG_IsOK(res1)) {
47994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47995 }
47996 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47997 ecode2 = SWIG_AsVal_int(obj1, &val2);
47998 if (!SWIG_IsOK(ecode2)) {
47999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48000 }
48001 arg2 = static_cast< int >(val2);
48002 {
48003 PyThreadState* __tstate = wxPyBeginAllowThreads();
48004 (arg1)->SetHGap(arg2);
48005 wxPyEndAllowThreads(__tstate);
48006 if (PyErr_Occurred()) SWIG_fail;
48007 }
48008 resultobj = SWIG_Py_Void();
48009 return resultobj;
48010 fail:
48011 return NULL;
48012 }
48013
48014
48015 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48016 PyObject *resultobj = 0;
48017 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48018 int result;
48019 void *argp1 = 0 ;
48020 int res1 = 0 ;
48021 PyObject *swig_obj[1] ;
48022
48023 if (!args) SWIG_fail;
48024 swig_obj[0] = args;
48025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48026 if (!SWIG_IsOK(res1)) {
48027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48028 }
48029 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48030 {
48031 PyThreadState* __tstate = wxPyBeginAllowThreads();
48032 result = (int)(arg1)->GetCols();
48033 wxPyEndAllowThreads(__tstate);
48034 if (PyErr_Occurred()) SWIG_fail;
48035 }
48036 resultobj = SWIG_From_int(static_cast< int >(result));
48037 return resultobj;
48038 fail:
48039 return NULL;
48040 }
48041
48042
48043 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48044 PyObject *resultobj = 0;
48045 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48046 int result;
48047 void *argp1 = 0 ;
48048 int res1 = 0 ;
48049 PyObject *swig_obj[1] ;
48050
48051 if (!args) SWIG_fail;
48052 swig_obj[0] = args;
48053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48054 if (!SWIG_IsOK(res1)) {
48055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48056 }
48057 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48058 {
48059 PyThreadState* __tstate = wxPyBeginAllowThreads();
48060 result = (int)(arg1)->GetRows();
48061 wxPyEndAllowThreads(__tstate);
48062 if (PyErr_Occurred()) SWIG_fail;
48063 }
48064 resultobj = SWIG_From_int(static_cast< int >(result));
48065 return resultobj;
48066 fail:
48067 return NULL;
48068 }
48069
48070
48071 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48072 PyObject *resultobj = 0;
48073 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48074 int result;
48075 void *argp1 = 0 ;
48076 int res1 = 0 ;
48077 PyObject *swig_obj[1] ;
48078
48079 if (!args) SWIG_fail;
48080 swig_obj[0] = args;
48081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48082 if (!SWIG_IsOK(res1)) {
48083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48084 }
48085 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48086 {
48087 PyThreadState* __tstate = wxPyBeginAllowThreads();
48088 result = (int)(arg1)->GetVGap();
48089 wxPyEndAllowThreads(__tstate);
48090 if (PyErr_Occurred()) SWIG_fail;
48091 }
48092 resultobj = SWIG_From_int(static_cast< int >(result));
48093 return resultobj;
48094 fail:
48095 return NULL;
48096 }
48097
48098
48099 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48100 PyObject *resultobj = 0;
48101 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48102 int result;
48103 void *argp1 = 0 ;
48104 int res1 = 0 ;
48105 PyObject *swig_obj[1] ;
48106
48107 if (!args) SWIG_fail;
48108 swig_obj[0] = args;
48109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48110 if (!SWIG_IsOK(res1)) {
48111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48112 }
48113 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48114 {
48115 PyThreadState* __tstate = wxPyBeginAllowThreads();
48116 result = (int)(arg1)->GetHGap();
48117 wxPyEndAllowThreads(__tstate);
48118 if (PyErr_Occurred()) SWIG_fail;
48119 }
48120 resultobj = SWIG_From_int(static_cast< int >(result));
48121 return resultobj;
48122 fail:
48123 return NULL;
48124 }
48125
48126
48127 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48128 PyObject *obj;
48129 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48130 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48131 return SWIG_Py_Void();
48132 }
48133
48134 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48135 return SWIG_Python_InitShadowInstance(args);
48136 }
48137
48138 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48139 PyObject *resultobj = 0;
48140 int arg1 = (int) 1 ;
48141 int arg2 = (int) 0 ;
48142 int arg3 = (int) 0 ;
48143 int arg4 = (int) 0 ;
48144 wxFlexGridSizer *result = 0 ;
48145 int val1 ;
48146 int ecode1 = 0 ;
48147 int val2 ;
48148 int ecode2 = 0 ;
48149 int val3 ;
48150 int ecode3 = 0 ;
48151 int val4 ;
48152 int ecode4 = 0 ;
48153 PyObject * obj0 = 0 ;
48154 PyObject * obj1 = 0 ;
48155 PyObject * obj2 = 0 ;
48156 PyObject * obj3 = 0 ;
48157 char * kwnames[] = {
48158 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48159 };
48160
48161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48162 if (obj0) {
48163 ecode1 = SWIG_AsVal_int(obj0, &val1);
48164 if (!SWIG_IsOK(ecode1)) {
48165 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48166 }
48167 arg1 = static_cast< int >(val1);
48168 }
48169 if (obj1) {
48170 ecode2 = SWIG_AsVal_int(obj1, &val2);
48171 if (!SWIG_IsOK(ecode2)) {
48172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48173 }
48174 arg2 = static_cast< int >(val2);
48175 }
48176 if (obj2) {
48177 ecode3 = SWIG_AsVal_int(obj2, &val3);
48178 if (!SWIG_IsOK(ecode3)) {
48179 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48180 }
48181 arg3 = static_cast< int >(val3);
48182 }
48183 if (obj3) {
48184 ecode4 = SWIG_AsVal_int(obj3, &val4);
48185 if (!SWIG_IsOK(ecode4)) {
48186 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48187 }
48188 arg4 = static_cast< int >(val4);
48189 }
48190 {
48191 PyThreadState* __tstate = wxPyBeginAllowThreads();
48192 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48193 wxPyEndAllowThreads(__tstate);
48194 if (PyErr_Occurred()) SWIG_fail;
48195 }
48196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48197 return resultobj;
48198 fail:
48199 return NULL;
48200 }
48201
48202
48203 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48204 PyObject *resultobj = 0;
48205 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48206 size_t arg2 ;
48207 int arg3 = (int) 0 ;
48208 void *argp1 = 0 ;
48209 int res1 = 0 ;
48210 size_t val2 ;
48211 int ecode2 = 0 ;
48212 int val3 ;
48213 int ecode3 = 0 ;
48214 PyObject * obj0 = 0 ;
48215 PyObject * obj1 = 0 ;
48216 PyObject * obj2 = 0 ;
48217 char * kwnames[] = {
48218 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48219 };
48220
48221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48223 if (!SWIG_IsOK(res1)) {
48224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48225 }
48226 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48227 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48228 if (!SWIG_IsOK(ecode2)) {
48229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48230 }
48231 arg2 = static_cast< size_t >(val2);
48232 if (obj2) {
48233 ecode3 = SWIG_AsVal_int(obj2, &val3);
48234 if (!SWIG_IsOK(ecode3)) {
48235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48236 }
48237 arg3 = static_cast< int >(val3);
48238 }
48239 {
48240 PyThreadState* __tstate = wxPyBeginAllowThreads();
48241 (arg1)->AddGrowableRow(arg2,arg3);
48242 wxPyEndAllowThreads(__tstate);
48243 if (PyErr_Occurred()) SWIG_fail;
48244 }
48245 resultobj = SWIG_Py_Void();
48246 return resultobj;
48247 fail:
48248 return NULL;
48249 }
48250
48251
48252 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48253 PyObject *resultobj = 0;
48254 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48255 size_t arg2 ;
48256 void *argp1 = 0 ;
48257 int res1 = 0 ;
48258 size_t val2 ;
48259 int ecode2 = 0 ;
48260 PyObject * obj0 = 0 ;
48261 PyObject * obj1 = 0 ;
48262 char * kwnames[] = {
48263 (char *) "self",(char *) "idx", NULL
48264 };
48265
48266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48268 if (!SWIG_IsOK(res1)) {
48269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48270 }
48271 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48272 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48273 if (!SWIG_IsOK(ecode2)) {
48274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48275 }
48276 arg2 = static_cast< size_t >(val2);
48277 {
48278 PyThreadState* __tstate = wxPyBeginAllowThreads();
48279 (arg1)->RemoveGrowableRow(arg2);
48280 wxPyEndAllowThreads(__tstate);
48281 if (PyErr_Occurred()) SWIG_fail;
48282 }
48283 resultobj = SWIG_Py_Void();
48284 return resultobj;
48285 fail:
48286 return NULL;
48287 }
48288
48289
48290 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48291 PyObject *resultobj = 0;
48292 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48293 size_t arg2 ;
48294 int arg3 = (int) 0 ;
48295 void *argp1 = 0 ;
48296 int res1 = 0 ;
48297 size_t val2 ;
48298 int ecode2 = 0 ;
48299 int val3 ;
48300 int ecode3 = 0 ;
48301 PyObject * obj0 = 0 ;
48302 PyObject * obj1 = 0 ;
48303 PyObject * obj2 = 0 ;
48304 char * kwnames[] = {
48305 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48306 };
48307
48308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48310 if (!SWIG_IsOK(res1)) {
48311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48312 }
48313 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48314 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48315 if (!SWIG_IsOK(ecode2)) {
48316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48317 }
48318 arg2 = static_cast< size_t >(val2);
48319 if (obj2) {
48320 ecode3 = SWIG_AsVal_int(obj2, &val3);
48321 if (!SWIG_IsOK(ecode3)) {
48322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48323 }
48324 arg3 = static_cast< int >(val3);
48325 }
48326 {
48327 PyThreadState* __tstate = wxPyBeginAllowThreads();
48328 (arg1)->AddGrowableCol(arg2,arg3);
48329 wxPyEndAllowThreads(__tstate);
48330 if (PyErr_Occurred()) SWIG_fail;
48331 }
48332 resultobj = SWIG_Py_Void();
48333 return resultobj;
48334 fail:
48335 return NULL;
48336 }
48337
48338
48339 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48340 PyObject *resultobj = 0;
48341 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48342 size_t arg2 ;
48343 void *argp1 = 0 ;
48344 int res1 = 0 ;
48345 size_t val2 ;
48346 int ecode2 = 0 ;
48347 PyObject * obj0 = 0 ;
48348 PyObject * obj1 = 0 ;
48349 char * kwnames[] = {
48350 (char *) "self",(char *) "idx", NULL
48351 };
48352
48353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48355 if (!SWIG_IsOK(res1)) {
48356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48357 }
48358 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48359 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48360 if (!SWIG_IsOK(ecode2)) {
48361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48362 }
48363 arg2 = static_cast< size_t >(val2);
48364 {
48365 PyThreadState* __tstate = wxPyBeginAllowThreads();
48366 (arg1)->RemoveGrowableCol(arg2);
48367 wxPyEndAllowThreads(__tstate);
48368 if (PyErr_Occurred()) SWIG_fail;
48369 }
48370 resultobj = SWIG_Py_Void();
48371 return resultobj;
48372 fail:
48373 return NULL;
48374 }
48375
48376
48377 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48378 PyObject *resultobj = 0;
48379 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48380 int arg2 ;
48381 void *argp1 = 0 ;
48382 int res1 = 0 ;
48383 int val2 ;
48384 int ecode2 = 0 ;
48385 PyObject * obj0 = 0 ;
48386 PyObject * obj1 = 0 ;
48387 char * kwnames[] = {
48388 (char *) "self",(char *) "direction", NULL
48389 };
48390
48391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48393 if (!SWIG_IsOK(res1)) {
48394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48395 }
48396 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48397 ecode2 = SWIG_AsVal_int(obj1, &val2);
48398 if (!SWIG_IsOK(ecode2)) {
48399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48400 }
48401 arg2 = static_cast< int >(val2);
48402 {
48403 PyThreadState* __tstate = wxPyBeginAllowThreads();
48404 (arg1)->SetFlexibleDirection(arg2);
48405 wxPyEndAllowThreads(__tstate);
48406 if (PyErr_Occurred()) SWIG_fail;
48407 }
48408 resultobj = SWIG_Py_Void();
48409 return resultobj;
48410 fail:
48411 return NULL;
48412 }
48413
48414
48415 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48416 PyObject *resultobj = 0;
48417 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48418 int result;
48419 void *argp1 = 0 ;
48420 int res1 = 0 ;
48421 PyObject *swig_obj[1] ;
48422
48423 if (!args) SWIG_fail;
48424 swig_obj[0] = args;
48425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48426 if (!SWIG_IsOK(res1)) {
48427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48428 }
48429 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48430 {
48431 PyThreadState* __tstate = wxPyBeginAllowThreads();
48432 result = (int)(arg1)->GetFlexibleDirection();
48433 wxPyEndAllowThreads(__tstate);
48434 if (PyErr_Occurred()) SWIG_fail;
48435 }
48436 resultobj = SWIG_From_int(static_cast< int >(result));
48437 return resultobj;
48438 fail:
48439 return NULL;
48440 }
48441
48442
48443 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48444 PyObject *resultobj = 0;
48445 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48446 wxFlexSizerGrowMode arg2 ;
48447 void *argp1 = 0 ;
48448 int res1 = 0 ;
48449 int val2 ;
48450 int ecode2 = 0 ;
48451 PyObject * obj0 = 0 ;
48452 PyObject * obj1 = 0 ;
48453 char * kwnames[] = {
48454 (char *) "self",(char *) "mode", NULL
48455 };
48456
48457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48459 if (!SWIG_IsOK(res1)) {
48460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48461 }
48462 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48463 ecode2 = SWIG_AsVal_int(obj1, &val2);
48464 if (!SWIG_IsOK(ecode2)) {
48465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48466 }
48467 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48468 {
48469 PyThreadState* __tstate = wxPyBeginAllowThreads();
48470 (arg1)->SetNonFlexibleGrowMode(arg2);
48471 wxPyEndAllowThreads(__tstate);
48472 if (PyErr_Occurred()) SWIG_fail;
48473 }
48474 resultobj = SWIG_Py_Void();
48475 return resultobj;
48476 fail:
48477 return NULL;
48478 }
48479
48480
48481 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48482 PyObject *resultobj = 0;
48483 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48484 wxFlexSizerGrowMode result;
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_wxFlexGridSizer, 0 | 0 );
48492 if (!SWIG_IsOK(res1)) {
48493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48494 }
48495 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48496 {
48497 PyThreadState* __tstate = wxPyBeginAllowThreads();
48498 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48499 wxPyEndAllowThreads(__tstate);
48500 if (PyErr_Occurred()) SWIG_fail;
48501 }
48502 resultobj = SWIG_From_int(static_cast< int >(result));
48503 return resultobj;
48504 fail:
48505 return NULL;
48506 }
48507
48508
48509 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48510 PyObject *resultobj = 0;
48511 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48512 wxArrayInt *result = 0 ;
48513 void *argp1 = 0 ;
48514 int res1 = 0 ;
48515 PyObject *swig_obj[1] ;
48516
48517 if (!args) SWIG_fail;
48518 swig_obj[0] = args;
48519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48520 if (!SWIG_IsOK(res1)) {
48521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48522 }
48523 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48524 {
48525 PyThreadState* __tstate = wxPyBeginAllowThreads();
48526 {
48527 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48528 result = (wxArrayInt *) &_result_ref;
48529 }
48530 wxPyEndAllowThreads(__tstate);
48531 if (PyErr_Occurred()) SWIG_fail;
48532 }
48533 {
48534 resultobj = PyList_New(0);
48535 size_t idx;
48536 for (idx = 0; idx < result->GetCount(); idx += 1) {
48537 PyObject* val = PyInt_FromLong( result->Item(idx) );
48538 PyList_Append(resultobj, val);
48539 Py_DECREF(val);
48540 }
48541 }
48542 return resultobj;
48543 fail:
48544 return NULL;
48545 }
48546
48547
48548 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48549 PyObject *resultobj = 0;
48550 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48551 wxArrayInt *result = 0 ;
48552 void *argp1 = 0 ;
48553 int res1 = 0 ;
48554 PyObject *swig_obj[1] ;
48555
48556 if (!args) SWIG_fail;
48557 swig_obj[0] = args;
48558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48559 if (!SWIG_IsOK(res1)) {
48560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48561 }
48562 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48563 {
48564 PyThreadState* __tstate = wxPyBeginAllowThreads();
48565 {
48566 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48567 result = (wxArrayInt *) &_result_ref;
48568 }
48569 wxPyEndAllowThreads(__tstate);
48570 if (PyErr_Occurred()) SWIG_fail;
48571 }
48572 {
48573 resultobj = PyList_New(0);
48574 size_t idx;
48575 for (idx = 0; idx < result->GetCount(); idx += 1) {
48576 PyObject* val = PyInt_FromLong( result->Item(idx) );
48577 PyList_Append(resultobj, val);
48578 Py_DECREF(val);
48579 }
48580 }
48581 return resultobj;
48582 fail:
48583 return NULL;
48584 }
48585
48586
48587 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48588 PyObject *obj;
48589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48590 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48591 return SWIG_Py_Void();
48592 }
48593
48594 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48595 return SWIG_Python_InitShadowInstance(args);
48596 }
48597
48598 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48599 PyObject *resultobj = 0;
48600 wxStdDialogButtonSizer *result = 0 ;
48601
48602 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48603 {
48604 PyThreadState* __tstate = wxPyBeginAllowThreads();
48605 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48606 wxPyEndAllowThreads(__tstate);
48607 if (PyErr_Occurred()) SWIG_fail;
48608 }
48609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48610 return resultobj;
48611 fail:
48612 return NULL;
48613 }
48614
48615
48616 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48617 PyObject *resultobj = 0;
48618 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48619 wxButton *arg2 = (wxButton *) 0 ;
48620 void *argp1 = 0 ;
48621 int res1 = 0 ;
48622 void *argp2 = 0 ;
48623 int res2 = 0 ;
48624 PyObject * obj0 = 0 ;
48625 PyObject * obj1 = 0 ;
48626 char * kwnames[] = {
48627 (char *) "self",(char *) "button", NULL
48628 };
48629
48630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48632 if (!SWIG_IsOK(res1)) {
48633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48634 }
48635 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48636 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48637 if (!SWIG_IsOK(res2)) {
48638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48639 }
48640 arg2 = reinterpret_cast< wxButton * >(argp2);
48641 {
48642 PyThreadState* __tstate = wxPyBeginAllowThreads();
48643 (arg1)->AddButton(arg2);
48644 wxPyEndAllowThreads(__tstate);
48645 if (PyErr_Occurred()) SWIG_fail;
48646 }
48647 resultobj = SWIG_Py_Void();
48648 return resultobj;
48649 fail:
48650 return NULL;
48651 }
48652
48653
48654 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48655 PyObject *resultobj = 0;
48656 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48657 void *argp1 = 0 ;
48658 int res1 = 0 ;
48659 PyObject *swig_obj[1] ;
48660
48661 if (!args) SWIG_fail;
48662 swig_obj[0] = args;
48663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48664 if (!SWIG_IsOK(res1)) {
48665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48666 }
48667 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48668 {
48669 PyThreadState* __tstate = wxPyBeginAllowThreads();
48670 (arg1)->Realize();
48671 wxPyEndAllowThreads(__tstate);
48672 if (PyErr_Occurred()) SWIG_fail;
48673 }
48674 resultobj = SWIG_Py_Void();
48675 return resultobj;
48676 fail:
48677 return NULL;
48678 }
48679
48680
48681 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48682 PyObject *resultobj = 0;
48683 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48684 wxButton *arg2 = (wxButton *) 0 ;
48685 void *argp1 = 0 ;
48686 int res1 = 0 ;
48687 void *argp2 = 0 ;
48688 int res2 = 0 ;
48689 PyObject * obj0 = 0 ;
48690 PyObject * obj1 = 0 ;
48691 char * kwnames[] = {
48692 (char *) "self",(char *) "button", NULL
48693 };
48694
48695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48697 if (!SWIG_IsOK(res1)) {
48698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48699 }
48700 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48701 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48702 if (!SWIG_IsOK(res2)) {
48703 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48704 }
48705 arg2 = reinterpret_cast< wxButton * >(argp2);
48706 {
48707 PyThreadState* __tstate = wxPyBeginAllowThreads();
48708 (arg1)->SetAffirmativeButton(arg2);
48709 wxPyEndAllowThreads(__tstate);
48710 if (PyErr_Occurred()) SWIG_fail;
48711 }
48712 resultobj = SWIG_Py_Void();
48713 return resultobj;
48714 fail:
48715 return NULL;
48716 }
48717
48718
48719 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48720 PyObject *resultobj = 0;
48721 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48722 wxButton *arg2 = (wxButton *) 0 ;
48723 void *argp1 = 0 ;
48724 int res1 = 0 ;
48725 void *argp2 = 0 ;
48726 int res2 = 0 ;
48727 PyObject * obj0 = 0 ;
48728 PyObject * obj1 = 0 ;
48729 char * kwnames[] = {
48730 (char *) "self",(char *) "button", NULL
48731 };
48732
48733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48735 if (!SWIG_IsOK(res1)) {
48736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48737 }
48738 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48739 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48740 if (!SWIG_IsOK(res2)) {
48741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48742 }
48743 arg2 = reinterpret_cast< wxButton * >(argp2);
48744 {
48745 PyThreadState* __tstate = wxPyBeginAllowThreads();
48746 (arg1)->SetNegativeButton(arg2);
48747 wxPyEndAllowThreads(__tstate);
48748 if (PyErr_Occurred()) SWIG_fail;
48749 }
48750 resultobj = SWIG_Py_Void();
48751 return resultobj;
48752 fail:
48753 return NULL;
48754 }
48755
48756
48757 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48758 PyObject *resultobj = 0;
48759 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48760 wxButton *arg2 = (wxButton *) 0 ;
48761 void *argp1 = 0 ;
48762 int res1 = 0 ;
48763 void *argp2 = 0 ;
48764 int res2 = 0 ;
48765 PyObject * obj0 = 0 ;
48766 PyObject * obj1 = 0 ;
48767 char * kwnames[] = {
48768 (char *) "self",(char *) "button", NULL
48769 };
48770
48771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48773 if (!SWIG_IsOK(res1)) {
48774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48775 }
48776 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48777 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48778 if (!SWIG_IsOK(res2)) {
48779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48780 }
48781 arg2 = reinterpret_cast< wxButton * >(argp2);
48782 {
48783 PyThreadState* __tstate = wxPyBeginAllowThreads();
48784 (arg1)->SetCancelButton(arg2);
48785 wxPyEndAllowThreads(__tstate);
48786 if (PyErr_Occurred()) SWIG_fail;
48787 }
48788 resultobj = SWIG_Py_Void();
48789 return resultobj;
48790 fail:
48791 return NULL;
48792 }
48793
48794
48795 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48796 PyObject *resultobj = 0;
48797 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48798 wxButton *result = 0 ;
48799 void *argp1 = 0 ;
48800 int res1 = 0 ;
48801 PyObject *swig_obj[1] ;
48802
48803 if (!args) SWIG_fail;
48804 swig_obj[0] = args;
48805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48806 if (!SWIG_IsOK(res1)) {
48807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48808 }
48809 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48810 {
48811 PyThreadState* __tstate = wxPyBeginAllowThreads();
48812 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48813 wxPyEndAllowThreads(__tstate);
48814 if (PyErr_Occurred()) SWIG_fail;
48815 }
48816 {
48817 resultobj = wxPyMake_wxObject(result, (bool)0);
48818 }
48819 return resultobj;
48820 fail:
48821 return NULL;
48822 }
48823
48824
48825 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48826 PyObject *resultobj = 0;
48827 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48828 wxButton *result = 0 ;
48829 void *argp1 = 0 ;
48830 int res1 = 0 ;
48831 PyObject *swig_obj[1] ;
48832
48833 if (!args) SWIG_fail;
48834 swig_obj[0] = args;
48835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48836 if (!SWIG_IsOK(res1)) {
48837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48838 }
48839 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48840 {
48841 PyThreadState* __tstate = wxPyBeginAllowThreads();
48842 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48843 wxPyEndAllowThreads(__tstate);
48844 if (PyErr_Occurred()) SWIG_fail;
48845 }
48846 {
48847 resultobj = wxPyMake_wxObject(result, (bool)0);
48848 }
48849 return resultobj;
48850 fail:
48851 return NULL;
48852 }
48853
48854
48855 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48856 PyObject *resultobj = 0;
48857 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48858 wxButton *result = 0 ;
48859 void *argp1 = 0 ;
48860 int res1 = 0 ;
48861 PyObject *swig_obj[1] ;
48862
48863 if (!args) SWIG_fail;
48864 swig_obj[0] = args;
48865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48866 if (!SWIG_IsOK(res1)) {
48867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48868 }
48869 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48870 {
48871 PyThreadState* __tstate = wxPyBeginAllowThreads();
48872 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48873 wxPyEndAllowThreads(__tstate);
48874 if (PyErr_Occurred()) SWIG_fail;
48875 }
48876 {
48877 resultobj = wxPyMake_wxObject(result, (bool)0);
48878 }
48879 return resultobj;
48880 fail:
48881 return NULL;
48882 }
48883
48884
48885 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48886 PyObject *resultobj = 0;
48887 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48888 wxButton *result = 0 ;
48889 void *argp1 = 0 ;
48890 int res1 = 0 ;
48891 PyObject *swig_obj[1] ;
48892
48893 if (!args) SWIG_fail;
48894 swig_obj[0] = args;
48895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48896 if (!SWIG_IsOK(res1)) {
48897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48898 }
48899 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48900 {
48901 PyThreadState* __tstate = wxPyBeginAllowThreads();
48902 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48903 wxPyEndAllowThreads(__tstate);
48904 if (PyErr_Occurred()) SWIG_fail;
48905 }
48906 {
48907 resultobj = wxPyMake_wxObject(result, (bool)0);
48908 }
48909 return resultobj;
48910 fail:
48911 return NULL;
48912 }
48913
48914
48915 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48916 PyObject *resultobj = 0;
48917 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48918 wxButton *result = 0 ;
48919 void *argp1 = 0 ;
48920 int res1 = 0 ;
48921 PyObject *swig_obj[1] ;
48922
48923 if (!args) SWIG_fail;
48924 swig_obj[0] = args;
48925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48926 if (!SWIG_IsOK(res1)) {
48927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48928 }
48929 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48930 {
48931 PyThreadState* __tstate = wxPyBeginAllowThreads();
48932 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48933 wxPyEndAllowThreads(__tstate);
48934 if (PyErr_Occurred()) SWIG_fail;
48935 }
48936 {
48937 resultobj = wxPyMake_wxObject(result, (bool)0);
48938 }
48939 return resultobj;
48940 fail:
48941 return NULL;
48942 }
48943
48944
48945 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48946 PyObject *obj;
48947 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48948 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48949 return SWIG_Py_Void();
48950 }
48951
48952 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48953 return SWIG_Python_InitShadowInstance(args);
48954 }
48955
48956 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48957 PyObject *resultobj = 0;
48958 int arg1 = (int) 0 ;
48959 int arg2 = (int) 0 ;
48960 wxGBPosition *result = 0 ;
48961 int val1 ;
48962 int ecode1 = 0 ;
48963 int val2 ;
48964 int ecode2 = 0 ;
48965 PyObject * obj0 = 0 ;
48966 PyObject * obj1 = 0 ;
48967 char * kwnames[] = {
48968 (char *) "row",(char *) "col", NULL
48969 };
48970
48971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48972 if (obj0) {
48973 ecode1 = SWIG_AsVal_int(obj0, &val1);
48974 if (!SWIG_IsOK(ecode1)) {
48975 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48976 }
48977 arg1 = static_cast< int >(val1);
48978 }
48979 if (obj1) {
48980 ecode2 = SWIG_AsVal_int(obj1, &val2);
48981 if (!SWIG_IsOK(ecode2)) {
48982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48983 }
48984 arg2 = static_cast< int >(val2);
48985 }
48986 {
48987 PyThreadState* __tstate = wxPyBeginAllowThreads();
48988 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48989 wxPyEndAllowThreads(__tstate);
48990 if (PyErr_Occurred()) SWIG_fail;
48991 }
48992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48993 return resultobj;
48994 fail:
48995 return NULL;
48996 }
48997
48998
48999 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49000 PyObject *resultobj = 0;
49001 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49002 void *argp1 = 0 ;
49003 int res1 = 0 ;
49004 PyObject *swig_obj[1] ;
49005
49006 if (!args) SWIG_fail;
49007 swig_obj[0] = args;
49008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49009 if (!SWIG_IsOK(res1)) {
49010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49011 }
49012 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49013 {
49014 PyThreadState* __tstate = wxPyBeginAllowThreads();
49015 delete arg1;
49016
49017 wxPyEndAllowThreads(__tstate);
49018 if (PyErr_Occurred()) SWIG_fail;
49019 }
49020 resultobj = SWIG_Py_Void();
49021 return resultobj;
49022 fail:
49023 return NULL;
49024 }
49025
49026
49027 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49028 PyObject *resultobj = 0;
49029 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49030 int result;
49031 void *argp1 = 0 ;
49032 int res1 = 0 ;
49033 PyObject *swig_obj[1] ;
49034
49035 if (!args) SWIG_fail;
49036 swig_obj[0] = args;
49037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49038 if (!SWIG_IsOK(res1)) {
49039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49040 }
49041 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49042 {
49043 PyThreadState* __tstate = wxPyBeginAllowThreads();
49044 result = (int)((wxGBPosition const *)arg1)->GetRow();
49045 wxPyEndAllowThreads(__tstate);
49046 if (PyErr_Occurred()) SWIG_fail;
49047 }
49048 resultobj = SWIG_From_int(static_cast< int >(result));
49049 return resultobj;
49050 fail:
49051 return NULL;
49052 }
49053
49054
49055 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49056 PyObject *resultobj = 0;
49057 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49058 int result;
49059 void *argp1 = 0 ;
49060 int res1 = 0 ;
49061 PyObject *swig_obj[1] ;
49062
49063 if (!args) SWIG_fail;
49064 swig_obj[0] = args;
49065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49066 if (!SWIG_IsOK(res1)) {
49067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49068 }
49069 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49070 {
49071 PyThreadState* __tstate = wxPyBeginAllowThreads();
49072 result = (int)((wxGBPosition const *)arg1)->GetCol();
49073 wxPyEndAllowThreads(__tstate);
49074 if (PyErr_Occurred()) SWIG_fail;
49075 }
49076 resultobj = SWIG_From_int(static_cast< int >(result));
49077 return resultobj;
49078 fail:
49079 return NULL;
49080 }
49081
49082
49083 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49084 PyObject *resultobj = 0;
49085 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49086 int arg2 ;
49087 void *argp1 = 0 ;
49088 int res1 = 0 ;
49089 int val2 ;
49090 int ecode2 = 0 ;
49091 PyObject * obj0 = 0 ;
49092 PyObject * obj1 = 0 ;
49093 char * kwnames[] = {
49094 (char *) "self",(char *) "row", NULL
49095 };
49096
49097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49099 if (!SWIG_IsOK(res1)) {
49100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49101 }
49102 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49103 ecode2 = SWIG_AsVal_int(obj1, &val2);
49104 if (!SWIG_IsOK(ecode2)) {
49105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49106 }
49107 arg2 = static_cast< int >(val2);
49108 {
49109 PyThreadState* __tstate = wxPyBeginAllowThreads();
49110 (arg1)->SetRow(arg2);
49111 wxPyEndAllowThreads(__tstate);
49112 if (PyErr_Occurred()) SWIG_fail;
49113 }
49114 resultobj = SWIG_Py_Void();
49115 return resultobj;
49116 fail:
49117 return NULL;
49118 }
49119
49120
49121 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49122 PyObject *resultobj = 0;
49123 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49124 int arg2 ;
49125 void *argp1 = 0 ;
49126 int res1 = 0 ;
49127 int val2 ;
49128 int ecode2 = 0 ;
49129 PyObject * obj0 = 0 ;
49130 PyObject * obj1 = 0 ;
49131 char * kwnames[] = {
49132 (char *) "self",(char *) "col", NULL
49133 };
49134
49135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49137 if (!SWIG_IsOK(res1)) {
49138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49139 }
49140 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49141 ecode2 = SWIG_AsVal_int(obj1, &val2);
49142 if (!SWIG_IsOK(ecode2)) {
49143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49144 }
49145 arg2 = static_cast< int >(val2);
49146 {
49147 PyThreadState* __tstate = wxPyBeginAllowThreads();
49148 (arg1)->SetCol(arg2);
49149 wxPyEndAllowThreads(__tstate);
49150 if (PyErr_Occurred()) SWIG_fail;
49151 }
49152 resultobj = SWIG_Py_Void();
49153 return resultobj;
49154 fail:
49155 return NULL;
49156 }
49157
49158
49159 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49160 PyObject *resultobj = 0;
49161 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49162 PyObject *arg2 = (PyObject *) 0 ;
49163 bool result;
49164 void *argp1 = 0 ;
49165 int res1 = 0 ;
49166 PyObject * obj0 = 0 ;
49167 PyObject * obj1 = 0 ;
49168 char * kwnames[] = {
49169 (char *) "self",(char *) "other", NULL
49170 };
49171
49172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49174 if (!SWIG_IsOK(res1)) {
49175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49176 }
49177 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49178 arg2 = obj1;
49179 {
49180 result = (bool)wxGBPosition___eq__(arg1,arg2);
49181 if (PyErr_Occurred()) SWIG_fail;
49182 }
49183 {
49184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49185 }
49186 return resultobj;
49187 fail:
49188 return NULL;
49189 }
49190
49191
49192 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49193 PyObject *resultobj = 0;
49194 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49195 PyObject *arg2 = (PyObject *) 0 ;
49196 bool result;
49197 void *argp1 = 0 ;
49198 int res1 = 0 ;
49199 PyObject * obj0 = 0 ;
49200 PyObject * obj1 = 0 ;
49201 char * kwnames[] = {
49202 (char *) "self",(char *) "other", NULL
49203 };
49204
49205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49207 if (!SWIG_IsOK(res1)) {
49208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49209 }
49210 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49211 arg2 = obj1;
49212 {
49213 result = (bool)wxGBPosition___ne__(arg1,arg2);
49214 if (PyErr_Occurred()) SWIG_fail;
49215 }
49216 {
49217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49218 }
49219 return resultobj;
49220 fail:
49221 return NULL;
49222 }
49223
49224
49225 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49226 PyObject *resultobj = 0;
49227 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49228 int arg2 = (int) 0 ;
49229 int arg3 = (int) 0 ;
49230 void *argp1 = 0 ;
49231 int res1 = 0 ;
49232 int val2 ;
49233 int ecode2 = 0 ;
49234 int val3 ;
49235 int ecode3 = 0 ;
49236 PyObject * obj0 = 0 ;
49237 PyObject * obj1 = 0 ;
49238 PyObject * obj2 = 0 ;
49239 char * kwnames[] = {
49240 (char *) "self",(char *) "row",(char *) "col", NULL
49241 };
49242
49243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49245 if (!SWIG_IsOK(res1)) {
49246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49247 }
49248 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49249 if (obj1) {
49250 ecode2 = SWIG_AsVal_int(obj1, &val2);
49251 if (!SWIG_IsOK(ecode2)) {
49252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49253 }
49254 arg2 = static_cast< int >(val2);
49255 }
49256 if (obj2) {
49257 ecode3 = SWIG_AsVal_int(obj2, &val3);
49258 if (!SWIG_IsOK(ecode3)) {
49259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49260 }
49261 arg3 = static_cast< int >(val3);
49262 }
49263 {
49264 PyThreadState* __tstate = wxPyBeginAllowThreads();
49265 wxGBPosition_Set(arg1,arg2,arg3);
49266 wxPyEndAllowThreads(__tstate);
49267 if (PyErr_Occurred()) SWIG_fail;
49268 }
49269 resultobj = SWIG_Py_Void();
49270 return resultobj;
49271 fail:
49272 return NULL;
49273 }
49274
49275
49276 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49277 PyObject *resultobj = 0;
49278 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49279 PyObject *result = 0 ;
49280 void *argp1 = 0 ;
49281 int res1 = 0 ;
49282 PyObject *swig_obj[1] ;
49283
49284 if (!args) SWIG_fail;
49285 swig_obj[0] = args;
49286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49287 if (!SWIG_IsOK(res1)) {
49288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49289 }
49290 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49291 {
49292 PyThreadState* __tstate = wxPyBeginAllowThreads();
49293 result = (PyObject *)wxGBPosition_Get(arg1);
49294 wxPyEndAllowThreads(__tstate);
49295 if (PyErr_Occurred()) SWIG_fail;
49296 }
49297 resultobj = result;
49298 return resultobj;
49299 fail:
49300 return NULL;
49301 }
49302
49303
49304 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49305 PyObject *obj;
49306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49307 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49308 return SWIG_Py_Void();
49309 }
49310
49311 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49312 return SWIG_Python_InitShadowInstance(args);
49313 }
49314
49315 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49316 PyObject *resultobj = 0;
49317 int arg1 = (int) 1 ;
49318 int arg2 = (int) 1 ;
49319 wxGBSpan *result = 0 ;
49320 int val1 ;
49321 int ecode1 = 0 ;
49322 int val2 ;
49323 int ecode2 = 0 ;
49324 PyObject * obj0 = 0 ;
49325 PyObject * obj1 = 0 ;
49326 char * kwnames[] = {
49327 (char *) "rowspan",(char *) "colspan", NULL
49328 };
49329
49330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49331 if (obj0) {
49332 ecode1 = SWIG_AsVal_int(obj0, &val1);
49333 if (!SWIG_IsOK(ecode1)) {
49334 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49335 }
49336 arg1 = static_cast< int >(val1);
49337 }
49338 if (obj1) {
49339 ecode2 = SWIG_AsVal_int(obj1, &val2);
49340 if (!SWIG_IsOK(ecode2)) {
49341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49342 }
49343 arg2 = static_cast< int >(val2);
49344 }
49345 {
49346 PyThreadState* __tstate = wxPyBeginAllowThreads();
49347 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49348 wxPyEndAllowThreads(__tstate);
49349 if (PyErr_Occurred()) SWIG_fail;
49350 }
49351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49352 return resultobj;
49353 fail:
49354 return NULL;
49355 }
49356
49357
49358 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49359 PyObject *resultobj = 0;
49360 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49361 void *argp1 = 0 ;
49362 int res1 = 0 ;
49363 PyObject *swig_obj[1] ;
49364
49365 if (!args) SWIG_fail;
49366 swig_obj[0] = args;
49367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49368 if (!SWIG_IsOK(res1)) {
49369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49370 }
49371 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49372 {
49373 PyThreadState* __tstate = wxPyBeginAllowThreads();
49374 delete arg1;
49375
49376 wxPyEndAllowThreads(__tstate);
49377 if (PyErr_Occurred()) SWIG_fail;
49378 }
49379 resultobj = SWIG_Py_Void();
49380 return resultobj;
49381 fail:
49382 return NULL;
49383 }
49384
49385
49386 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49387 PyObject *resultobj = 0;
49388 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49389 int result;
49390 void *argp1 = 0 ;
49391 int res1 = 0 ;
49392 PyObject *swig_obj[1] ;
49393
49394 if (!args) SWIG_fail;
49395 swig_obj[0] = args;
49396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49397 if (!SWIG_IsOK(res1)) {
49398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49399 }
49400 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49401 {
49402 PyThreadState* __tstate = wxPyBeginAllowThreads();
49403 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49404 wxPyEndAllowThreads(__tstate);
49405 if (PyErr_Occurred()) SWIG_fail;
49406 }
49407 resultobj = SWIG_From_int(static_cast< int >(result));
49408 return resultobj;
49409 fail:
49410 return NULL;
49411 }
49412
49413
49414 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49415 PyObject *resultobj = 0;
49416 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49417 int result;
49418 void *argp1 = 0 ;
49419 int res1 = 0 ;
49420 PyObject *swig_obj[1] ;
49421
49422 if (!args) SWIG_fail;
49423 swig_obj[0] = args;
49424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49425 if (!SWIG_IsOK(res1)) {
49426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49427 }
49428 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49429 {
49430 PyThreadState* __tstate = wxPyBeginAllowThreads();
49431 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49432 wxPyEndAllowThreads(__tstate);
49433 if (PyErr_Occurred()) SWIG_fail;
49434 }
49435 resultobj = SWIG_From_int(static_cast< int >(result));
49436 return resultobj;
49437 fail:
49438 return NULL;
49439 }
49440
49441
49442 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49443 PyObject *resultobj = 0;
49444 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49445 int arg2 ;
49446 void *argp1 = 0 ;
49447 int res1 = 0 ;
49448 int val2 ;
49449 int ecode2 = 0 ;
49450 PyObject * obj0 = 0 ;
49451 PyObject * obj1 = 0 ;
49452 char * kwnames[] = {
49453 (char *) "self",(char *) "rowspan", NULL
49454 };
49455
49456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49458 if (!SWIG_IsOK(res1)) {
49459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49460 }
49461 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49462 ecode2 = SWIG_AsVal_int(obj1, &val2);
49463 if (!SWIG_IsOK(ecode2)) {
49464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49465 }
49466 arg2 = static_cast< int >(val2);
49467 {
49468 PyThreadState* __tstate = wxPyBeginAllowThreads();
49469 (arg1)->SetRowspan(arg2);
49470 wxPyEndAllowThreads(__tstate);
49471 if (PyErr_Occurred()) SWIG_fail;
49472 }
49473 resultobj = SWIG_Py_Void();
49474 return resultobj;
49475 fail:
49476 return NULL;
49477 }
49478
49479
49480 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49481 PyObject *resultobj = 0;
49482 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49483 int arg2 ;
49484 void *argp1 = 0 ;
49485 int res1 = 0 ;
49486 int val2 ;
49487 int ecode2 = 0 ;
49488 PyObject * obj0 = 0 ;
49489 PyObject * obj1 = 0 ;
49490 char * kwnames[] = {
49491 (char *) "self",(char *) "colspan", NULL
49492 };
49493
49494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49496 if (!SWIG_IsOK(res1)) {
49497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49498 }
49499 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49500 ecode2 = SWIG_AsVal_int(obj1, &val2);
49501 if (!SWIG_IsOK(ecode2)) {
49502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49503 }
49504 arg2 = static_cast< int >(val2);
49505 {
49506 PyThreadState* __tstate = wxPyBeginAllowThreads();
49507 (arg1)->SetColspan(arg2);
49508 wxPyEndAllowThreads(__tstate);
49509 if (PyErr_Occurred()) SWIG_fail;
49510 }
49511 resultobj = SWIG_Py_Void();
49512 return resultobj;
49513 fail:
49514 return NULL;
49515 }
49516
49517
49518 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49519 PyObject *resultobj = 0;
49520 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49521 PyObject *arg2 = (PyObject *) 0 ;
49522 bool result;
49523 void *argp1 = 0 ;
49524 int res1 = 0 ;
49525 PyObject * obj0 = 0 ;
49526 PyObject * obj1 = 0 ;
49527 char * kwnames[] = {
49528 (char *) "self",(char *) "other", NULL
49529 };
49530
49531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49533 if (!SWIG_IsOK(res1)) {
49534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49535 }
49536 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49537 arg2 = obj1;
49538 {
49539 result = (bool)wxGBSpan___eq__(arg1,arg2);
49540 if (PyErr_Occurred()) SWIG_fail;
49541 }
49542 {
49543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49544 }
49545 return resultobj;
49546 fail:
49547 return NULL;
49548 }
49549
49550
49551 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49552 PyObject *resultobj = 0;
49553 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49554 PyObject *arg2 = (PyObject *) 0 ;
49555 bool result;
49556 void *argp1 = 0 ;
49557 int res1 = 0 ;
49558 PyObject * obj0 = 0 ;
49559 PyObject * obj1 = 0 ;
49560 char * kwnames[] = {
49561 (char *) "self",(char *) "other", NULL
49562 };
49563
49564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49566 if (!SWIG_IsOK(res1)) {
49567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49568 }
49569 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49570 arg2 = obj1;
49571 {
49572 result = (bool)wxGBSpan___ne__(arg1,arg2);
49573 if (PyErr_Occurred()) SWIG_fail;
49574 }
49575 {
49576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49577 }
49578 return resultobj;
49579 fail:
49580 return NULL;
49581 }
49582
49583
49584 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49585 PyObject *resultobj = 0;
49586 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49587 int arg2 = (int) 1 ;
49588 int arg3 = (int) 1 ;
49589 void *argp1 = 0 ;
49590 int res1 = 0 ;
49591 int val2 ;
49592 int ecode2 = 0 ;
49593 int val3 ;
49594 int ecode3 = 0 ;
49595 PyObject * obj0 = 0 ;
49596 PyObject * obj1 = 0 ;
49597 PyObject * obj2 = 0 ;
49598 char * kwnames[] = {
49599 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49600 };
49601
49602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49604 if (!SWIG_IsOK(res1)) {
49605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49606 }
49607 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49608 if (obj1) {
49609 ecode2 = SWIG_AsVal_int(obj1, &val2);
49610 if (!SWIG_IsOK(ecode2)) {
49611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49612 }
49613 arg2 = static_cast< int >(val2);
49614 }
49615 if (obj2) {
49616 ecode3 = SWIG_AsVal_int(obj2, &val3);
49617 if (!SWIG_IsOK(ecode3)) {
49618 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49619 }
49620 arg3 = static_cast< int >(val3);
49621 }
49622 {
49623 PyThreadState* __tstate = wxPyBeginAllowThreads();
49624 wxGBSpan_Set(arg1,arg2,arg3);
49625 wxPyEndAllowThreads(__tstate);
49626 if (PyErr_Occurred()) SWIG_fail;
49627 }
49628 resultobj = SWIG_Py_Void();
49629 return resultobj;
49630 fail:
49631 return NULL;
49632 }
49633
49634
49635 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49636 PyObject *resultobj = 0;
49637 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49638 PyObject *result = 0 ;
49639 void *argp1 = 0 ;
49640 int res1 = 0 ;
49641 PyObject *swig_obj[1] ;
49642
49643 if (!args) SWIG_fail;
49644 swig_obj[0] = args;
49645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49646 if (!SWIG_IsOK(res1)) {
49647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49648 }
49649 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49650 {
49651 PyThreadState* __tstate = wxPyBeginAllowThreads();
49652 result = (PyObject *)wxGBSpan_Get(arg1);
49653 wxPyEndAllowThreads(__tstate);
49654 if (PyErr_Occurred()) SWIG_fail;
49655 }
49656 resultobj = result;
49657 return resultobj;
49658 fail:
49659 return NULL;
49660 }
49661
49662
49663 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49664 PyObject *obj;
49665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49666 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49667 return SWIG_Py_Void();
49668 }
49669
49670 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49671 return SWIG_Python_InitShadowInstance(args);
49672 }
49673
49674 SWIGINTERN int DefaultSpan_set(PyObject *) {
49675 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49676 return 1;
49677 }
49678
49679
49680 SWIGINTERN PyObject *DefaultSpan_get(void) {
49681 PyObject *pyobj = 0;
49682
49683 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49684 return pyobj;
49685 }
49686
49687
49688 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49689 PyObject *resultobj = 0;
49690 wxGBSizerItem *result = 0 ;
49691
49692 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49693 {
49694 PyThreadState* __tstate = wxPyBeginAllowThreads();
49695 result = (wxGBSizerItem *)new wxGBSizerItem();
49696 wxPyEndAllowThreads(__tstate);
49697 if (PyErr_Occurred()) SWIG_fail;
49698 }
49699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49700 return resultobj;
49701 fail:
49702 return NULL;
49703 }
49704
49705
49706 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49707 PyObject *resultobj = 0;
49708 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49709 void *argp1 = 0 ;
49710 int res1 = 0 ;
49711 PyObject *swig_obj[1] ;
49712
49713 if (!args) SWIG_fail;
49714 swig_obj[0] = args;
49715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49716 if (!SWIG_IsOK(res1)) {
49717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49718 }
49719 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49720 {
49721 PyThreadState* __tstate = wxPyBeginAllowThreads();
49722 delete arg1;
49723
49724 wxPyEndAllowThreads(__tstate);
49725 if (PyErr_Occurred()) SWIG_fail;
49726 }
49727 resultobj = SWIG_Py_Void();
49728 return resultobj;
49729 fail:
49730 return NULL;
49731 }
49732
49733
49734 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49735 PyObject *resultobj = 0;
49736 wxWindow *arg1 = (wxWindow *) 0 ;
49737 wxGBPosition *arg2 = 0 ;
49738 wxGBSpan *arg3 = 0 ;
49739 int arg4 ;
49740 int arg5 ;
49741 PyObject *arg6 = (PyObject *) NULL ;
49742 wxGBSizerItem *result = 0 ;
49743 void *argp1 = 0 ;
49744 int res1 = 0 ;
49745 wxGBPosition temp2 ;
49746 wxGBSpan temp3 ;
49747 int val4 ;
49748 int ecode4 = 0 ;
49749 int val5 ;
49750 int ecode5 = 0 ;
49751 PyObject * obj0 = 0 ;
49752 PyObject * obj1 = 0 ;
49753 PyObject * obj2 = 0 ;
49754 PyObject * obj3 = 0 ;
49755 PyObject * obj4 = 0 ;
49756 PyObject * obj5 = 0 ;
49757 char * kwnames[] = {
49758 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49759 };
49760
49761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49763 if (!SWIG_IsOK(res1)) {
49764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49765 }
49766 arg1 = reinterpret_cast< wxWindow * >(argp1);
49767 {
49768 arg2 = &temp2;
49769 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49770 }
49771 {
49772 arg3 = &temp3;
49773 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49774 }
49775 ecode4 = SWIG_AsVal_int(obj3, &val4);
49776 if (!SWIG_IsOK(ecode4)) {
49777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49778 }
49779 arg4 = static_cast< int >(val4);
49780 ecode5 = SWIG_AsVal_int(obj4, &val5);
49781 if (!SWIG_IsOK(ecode5)) {
49782 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49783 }
49784 arg5 = static_cast< int >(val5);
49785 if (obj5) {
49786 arg6 = obj5;
49787 }
49788 {
49789 PyThreadState* __tstate = wxPyBeginAllowThreads();
49790 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49791 wxPyEndAllowThreads(__tstate);
49792 if (PyErr_Occurred()) SWIG_fail;
49793 }
49794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49795 return resultobj;
49796 fail:
49797 return NULL;
49798 }
49799
49800
49801 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49802 PyObject *resultobj = 0;
49803 wxSizer *arg1 = (wxSizer *) 0 ;
49804 wxGBPosition *arg2 = 0 ;
49805 wxGBSpan *arg3 = 0 ;
49806 int arg4 ;
49807 int arg5 ;
49808 PyObject *arg6 = (PyObject *) NULL ;
49809 wxGBSizerItem *result = 0 ;
49810 int res1 = 0 ;
49811 wxGBPosition temp2 ;
49812 wxGBSpan temp3 ;
49813 int val4 ;
49814 int ecode4 = 0 ;
49815 int val5 ;
49816 int ecode5 = 0 ;
49817 PyObject * obj0 = 0 ;
49818 PyObject * obj1 = 0 ;
49819 PyObject * obj2 = 0 ;
49820 PyObject * obj3 = 0 ;
49821 PyObject * obj4 = 0 ;
49822 PyObject * obj5 = 0 ;
49823 char * kwnames[] = {
49824 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49825 };
49826
49827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49828 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49829 if (!SWIG_IsOK(res1)) {
49830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49831 }
49832 {
49833 arg2 = &temp2;
49834 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49835 }
49836 {
49837 arg3 = &temp3;
49838 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49839 }
49840 ecode4 = SWIG_AsVal_int(obj3, &val4);
49841 if (!SWIG_IsOK(ecode4)) {
49842 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49843 }
49844 arg4 = static_cast< int >(val4);
49845 ecode5 = SWIG_AsVal_int(obj4, &val5);
49846 if (!SWIG_IsOK(ecode5)) {
49847 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49848 }
49849 arg5 = static_cast< int >(val5);
49850 if (obj5) {
49851 arg6 = obj5;
49852 }
49853 {
49854 PyThreadState* __tstate = wxPyBeginAllowThreads();
49855 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49856 wxPyEndAllowThreads(__tstate);
49857 if (PyErr_Occurred()) SWIG_fail;
49858 }
49859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49860 return resultobj;
49861 fail:
49862 return NULL;
49863 }
49864
49865
49866 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49867 PyObject *resultobj = 0;
49868 int arg1 ;
49869 int arg2 ;
49870 wxGBPosition *arg3 = 0 ;
49871 wxGBSpan *arg4 = 0 ;
49872 int arg5 ;
49873 int arg6 ;
49874 PyObject *arg7 = (PyObject *) NULL ;
49875 wxGBSizerItem *result = 0 ;
49876 int val1 ;
49877 int ecode1 = 0 ;
49878 int val2 ;
49879 int ecode2 = 0 ;
49880 wxGBPosition temp3 ;
49881 wxGBSpan temp4 ;
49882 int val5 ;
49883 int ecode5 = 0 ;
49884 int val6 ;
49885 int ecode6 = 0 ;
49886 PyObject * obj0 = 0 ;
49887 PyObject * obj1 = 0 ;
49888 PyObject * obj2 = 0 ;
49889 PyObject * obj3 = 0 ;
49890 PyObject * obj4 = 0 ;
49891 PyObject * obj5 = 0 ;
49892 PyObject * obj6 = 0 ;
49893 char * kwnames[] = {
49894 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49895 };
49896
49897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49898 ecode1 = SWIG_AsVal_int(obj0, &val1);
49899 if (!SWIG_IsOK(ecode1)) {
49900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49901 }
49902 arg1 = static_cast< int >(val1);
49903 ecode2 = SWIG_AsVal_int(obj1, &val2);
49904 if (!SWIG_IsOK(ecode2)) {
49905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49906 }
49907 arg2 = static_cast< int >(val2);
49908 {
49909 arg3 = &temp3;
49910 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49911 }
49912 {
49913 arg4 = &temp4;
49914 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49915 }
49916 ecode5 = SWIG_AsVal_int(obj4, &val5);
49917 if (!SWIG_IsOK(ecode5)) {
49918 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49919 }
49920 arg5 = static_cast< int >(val5);
49921 ecode6 = SWIG_AsVal_int(obj5, &val6);
49922 if (!SWIG_IsOK(ecode6)) {
49923 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49924 }
49925 arg6 = static_cast< int >(val6);
49926 if (obj6) {
49927 arg7 = obj6;
49928 }
49929 {
49930 PyThreadState* __tstate = wxPyBeginAllowThreads();
49931 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49932 wxPyEndAllowThreads(__tstate);
49933 if (PyErr_Occurred()) SWIG_fail;
49934 }
49935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49936 return resultobj;
49937 fail:
49938 return NULL;
49939 }
49940
49941
49942 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49943 PyObject *resultobj = 0;
49944 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49945 wxGBPosition result;
49946 void *argp1 = 0 ;
49947 int res1 = 0 ;
49948 PyObject *swig_obj[1] ;
49949
49950 if (!args) SWIG_fail;
49951 swig_obj[0] = args;
49952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49953 if (!SWIG_IsOK(res1)) {
49954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49955 }
49956 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49957 {
49958 PyThreadState* __tstate = wxPyBeginAllowThreads();
49959 result = ((wxGBSizerItem const *)arg1)->GetPos();
49960 wxPyEndAllowThreads(__tstate);
49961 if (PyErr_Occurred()) SWIG_fail;
49962 }
49963 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49964 return resultobj;
49965 fail:
49966 return NULL;
49967 }
49968
49969
49970 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49971 PyObject *resultobj = 0;
49972 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49973 wxGBSpan result;
49974 void *argp1 = 0 ;
49975 int res1 = 0 ;
49976 PyObject *swig_obj[1] ;
49977
49978 if (!args) SWIG_fail;
49979 swig_obj[0] = args;
49980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49981 if (!SWIG_IsOK(res1)) {
49982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49983 }
49984 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49985 {
49986 PyThreadState* __tstate = wxPyBeginAllowThreads();
49987 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49988 wxPyEndAllowThreads(__tstate);
49989 if (PyErr_Occurred()) SWIG_fail;
49990 }
49991 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49992 return resultobj;
49993 fail:
49994 return NULL;
49995 }
49996
49997
49998 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49999 PyObject *resultobj = 0;
50000 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50001 wxGBPosition *arg2 = 0 ;
50002 bool result;
50003 void *argp1 = 0 ;
50004 int res1 = 0 ;
50005 wxGBPosition temp2 ;
50006 PyObject * obj0 = 0 ;
50007 PyObject * obj1 = 0 ;
50008 char * kwnames[] = {
50009 (char *) "self",(char *) "pos", NULL
50010 };
50011
50012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50014 if (!SWIG_IsOK(res1)) {
50015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50016 }
50017 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50018 {
50019 arg2 = &temp2;
50020 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50021 }
50022 {
50023 PyThreadState* __tstate = wxPyBeginAllowThreads();
50024 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50025 wxPyEndAllowThreads(__tstate);
50026 if (PyErr_Occurred()) SWIG_fail;
50027 }
50028 {
50029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50030 }
50031 return resultobj;
50032 fail:
50033 return NULL;
50034 }
50035
50036
50037 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50038 PyObject *resultobj = 0;
50039 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50040 wxGBSpan *arg2 = 0 ;
50041 bool result;
50042 void *argp1 = 0 ;
50043 int res1 = 0 ;
50044 wxGBSpan temp2 ;
50045 PyObject * obj0 = 0 ;
50046 PyObject * obj1 = 0 ;
50047 char * kwnames[] = {
50048 (char *) "self",(char *) "span", NULL
50049 };
50050
50051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50053 if (!SWIG_IsOK(res1)) {
50054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50055 }
50056 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50057 {
50058 arg2 = &temp2;
50059 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50060 }
50061 {
50062 PyThreadState* __tstate = wxPyBeginAllowThreads();
50063 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50064 wxPyEndAllowThreads(__tstate);
50065 if (PyErr_Occurred()) SWIG_fail;
50066 }
50067 {
50068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50069 }
50070 return resultobj;
50071 fail:
50072 return NULL;
50073 }
50074
50075
50076 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50077 PyObject *resultobj = 0;
50078 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50079 wxGBSizerItem *arg2 = 0 ;
50080 bool result;
50081 void *argp1 = 0 ;
50082 int res1 = 0 ;
50083 void *argp2 = 0 ;
50084 int res2 = 0 ;
50085 PyObject * obj0 = 0 ;
50086 PyObject * obj1 = 0 ;
50087 char * kwnames[] = {
50088 (char *) "self",(char *) "other", NULL
50089 };
50090
50091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50093 if (!SWIG_IsOK(res1)) {
50094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50095 }
50096 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50097 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50098 if (!SWIG_IsOK(res2)) {
50099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50100 }
50101 if (!argp2) {
50102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50103 }
50104 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50105 {
50106 PyThreadState* __tstate = wxPyBeginAllowThreads();
50107 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50108 wxPyEndAllowThreads(__tstate);
50109 if (PyErr_Occurred()) SWIG_fail;
50110 }
50111 {
50112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50113 }
50114 return resultobj;
50115 fail:
50116 return NULL;
50117 }
50118
50119
50120 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50121 PyObject *resultobj = 0;
50122 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50123 wxGBPosition *arg2 = 0 ;
50124 wxGBSpan *arg3 = 0 ;
50125 bool result;
50126 void *argp1 = 0 ;
50127 int res1 = 0 ;
50128 wxGBPosition temp2 ;
50129 wxGBSpan temp3 ;
50130 PyObject * obj0 = 0 ;
50131 PyObject * obj1 = 0 ;
50132 PyObject * obj2 = 0 ;
50133 char * kwnames[] = {
50134 (char *) "self",(char *) "pos",(char *) "span", NULL
50135 };
50136
50137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50139 if (!SWIG_IsOK(res1)) {
50140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50141 }
50142 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50143 {
50144 arg2 = &temp2;
50145 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50146 }
50147 {
50148 arg3 = &temp3;
50149 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50150 }
50151 {
50152 PyThreadState* __tstate = wxPyBeginAllowThreads();
50153 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50154 wxPyEndAllowThreads(__tstate);
50155 if (PyErr_Occurred()) SWIG_fail;
50156 }
50157 {
50158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50159 }
50160 return resultobj;
50161 fail:
50162 return NULL;
50163 }
50164
50165
50166 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50167 PyObject *resultobj = 0;
50168 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50169 wxGBPosition result;
50170 void *argp1 = 0 ;
50171 int res1 = 0 ;
50172 PyObject *swig_obj[1] ;
50173
50174 if (!args) SWIG_fail;
50175 swig_obj[0] = args;
50176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50177 if (!SWIG_IsOK(res1)) {
50178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50179 }
50180 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50181 {
50182 PyThreadState* __tstate = wxPyBeginAllowThreads();
50183 result = wxGBSizerItem_GetEndPos(arg1);
50184 wxPyEndAllowThreads(__tstate);
50185 if (PyErr_Occurred()) SWIG_fail;
50186 }
50187 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50188 return resultobj;
50189 fail:
50190 return NULL;
50191 }
50192
50193
50194 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50195 PyObject *resultobj = 0;
50196 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50197 wxGridBagSizer *result = 0 ;
50198 void *argp1 = 0 ;
50199 int res1 = 0 ;
50200 PyObject *swig_obj[1] ;
50201
50202 if (!args) SWIG_fail;
50203 swig_obj[0] = args;
50204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50205 if (!SWIG_IsOK(res1)) {
50206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50207 }
50208 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50209 {
50210 PyThreadState* __tstate = wxPyBeginAllowThreads();
50211 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50212 wxPyEndAllowThreads(__tstate);
50213 if (PyErr_Occurred()) SWIG_fail;
50214 }
50215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50216 return resultobj;
50217 fail:
50218 return NULL;
50219 }
50220
50221
50222 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50223 PyObject *resultobj = 0;
50224 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50225 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50226 void *argp1 = 0 ;
50227 int res1 = 0 ;
50228 void *argp2 = 0 ;
50229 int res2 = 0 ;
50230 PyObject * obj0 = 0 ;
50231 PyObject * obj1 = 0 ;
50232 char * kwnames[] = {
50233 (char *) "self",(char *) "sizer", NULL
50234 };
50235
50236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50238 if (!SWIG_IsOK(res1)) {
50239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50240 }
50241 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50242 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50243 if (!SWIG_IsOK(res2)) {
50244 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50245 }
50246 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50247 {
50248 PyThreadState* __tstate = wxPyBeginAllowThreads();
50249 (arg1)->SetGBSizer(arg2);
50250 wxPyEndAllowThreads(__tstate);
50251 if (PyErr_Occurred()) SWIG_fail;
50252 }
50253 resultobj = SWIG_Py_Void();
50254 return resultobj;
50255 fail:
50256 return NULL;
50257 }
50258
50259
50260 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50261 PyObject *obj;
50262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50263 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50264 return SWIG_Py_Void();
50265 }
50266
50267 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50268 return SWIG_Python_InitShadowInstance(args);
50269 }
50270
50271 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50272 PyObject *resultobj = 0;
50273 int arg1 = (int) 0 ;
50274 int arg2 = (int) 0 ;
50275 wxGridBagSizer *result = 0 ;
50276 int val1 ;
50277 int ecode1 = 0 ;
50278 int val2 ;
50279 int ecode2 = 0 ;
50280 PyObject * obj0 = 0 ;
50281 PyObject * obj1 = 0 ;
50282 char * kwnames[] = {
50283 (char *) "vgap",(char *) "hgap", NULL
50284 };
50285
50286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50287 if (obj0) {
50288 ecode1 = SWIG_AsVal_int(obj0, &val1);
50289 if (!SWIG_IsOK(ecode1)) {
50290 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50291 }
50292 arg1 = static_cast< int >(val1);
50293 }
50294 if (obj1) {
50295 ecode2 = SWIG_AsVal_int(obj1, &val2);
50296 if (!SWIG_IsOK(ecode2)) {
50297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50298 }
50299 arg2 = static_cast< int >(val2);
50300 }
50301 {
50302 PyThreadState* __tstate = wxPyBeginAllowThreads();
50303 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50304 wxPyEndAllowThreads(__tstate);
50305 if (PyErr_Occurred()) SWIG_fail;
50306 }
50307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50308 return resultobj;
50309 fail:
50310 return NULL;
50311 }
50312
50313
50314 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50315 PyObject *resultobj = 0;
50316 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50317 PyObject *arg2 = (PyObject *) 0 ;
50318 wxGBPosition *arg3 = 0 ;
50319 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50320 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50321 int arg5 = (int) 0 ;
50322 int arg6 = (int) 0 ;
50323 PyObject *arg7 = (PyObject *) NULL ;
50324 wxGBSizerItem *result = 0 ;
50325 void *argp1 = 0 ;
50326 int res1 = 0 ;
50327 wxGBPosition temp3 ;
50328 wxGBSpan temp4 ;
50329 int val5 ;
50330 int ecode5 = 0 ;
50331 int val6 ;
50332 int ecode6 = 0 ;
50333 PyObject * obj0 = 0 ;
50334 PyObject * obj1 = 0 ;
50335 PyObject * obj2 = 0 ;
50336 PyObject * obj3 = 0 ;
50337 PyObject * obj4 = 0 ;
50338 PyObject * obj5 = 0 ;
50339 PyObject * obj6 = 0 ;
50340 char * kwnames[] = {
50341 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50342 };
50343
50344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50346 if (!SWIG_IsOK(res1)) {
50347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50348 }
50349 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50350 arg2 = obj1;
50351 {
50352 arg3 = &temp3;
50353 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50354 }
50355 if (obj3) {
50356 {
50357 arg4 = &temp4;
50358 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50359 }
50360 }
50361 if (obj4) {
50362 ecode5 = SWIG_AsVal_int(obj4, &val5);
50363 if (!SWIG_IsOK(ecode5)) {
50364 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50365 }
50366 arg5 = static_cast< int >(val5);
50367 }
50368 if (obj5) {
50369 ecode6 = SWIG_AsVal_int(obj5, &val6);
50370 if (!SWIG_IsOK(ecode6)) {
50371 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50372 }
50373 arg6 = static_cast< int >(val6);
50374 }
50375 if (obj6) {
50376 arg7 = obj6;
50377 }
50378 {
50379 PyThreadState* __tstate = wxPyBeginAllowThreads();
50380 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50381 wxPyEndAllowThreads(__tstate);
50382 if (PyErr_Occurred()) SWIG_fail;
50383 }
50384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50385 return resultobj;
50386 fail:
50387 return NULL;
50388 }
50389
50390
50391 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50392 PyObject *resultobj = 0;
50393 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50394 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50395 wxGBSizerItem *result = 0 ;
50396 void *argp1 = 0 ;
50397 int res1 = 0 ;
50398 int res2 = 0 ;
50399 PyObject * obj0 = 0 ;
50400 PyObject * obj1 = 0 ;
50401 char * kwnames[] = {
50402 (char *) "self",(char *) "item", NULL
50403 };
50404
50405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50407 if (!SWIG_IsOK(res1)) {
50408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50409 }
50410 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50411 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50412 if (!SWIG_IsOK(res2)) {
50413 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50414 }
50415 {
50416 PyThreadState* __tstate = wxPyBeginAllowThreads();
50417 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50418 wxPyEndAllowThreads(__tstate);
50419 if (PyErr_Occurred()) SWIG_fail;
50420 }
50421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50422 return resultobj;
50423 fail:
50424 return NULL;
50425 }
50426
50427
50428 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50429 PyObject *resultobj = 0;
50430 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50431 int arg2 ;
50432 int arg3 ;
50433 wxSize result;
50434 void *argp1 = 0 ;
50435 int res1 = 0 ;
50436 int val2 ;
50437 int ecode2 = 0 ;
50438 int val3 ;
50439 int ecode3 = 0 ;
50440 PyObject * obj0 = 0 ;
50441 PyObject * obj1 = 0 ;
50442 PyObject * obj2 = 0 ;
50443 char * kwnames[] = {
50444 (char *) "self",(char *) "row",(char *) "col", NULL
50445 };
50446
50447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50449 if (!SWIG_IsOK(res1)) {
50450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50451 }
50452 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50453 ecode2 = SWIG_AsVal_int(obj1, &val2);
50454 if (!SWIG_IsOK(ecode2)) {
50455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50456 }
50457 arg2 = static_cast< int >(val2);
50458 ecode3 = SWIG_AsVal_int(obj2, &val3);
50459 if (!SWIG_IsOK(ecode3)) {
50460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50461 }
50462 arg3 = static_cast< int >(val3);
50463 {
50464 PyThreadState* __tstate = wxPyBeginAllowThreads();
50465 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50466 wxPyEndAllowThreads(__tstate);
50467 if (PyErr_Occurred()) SWIG_fail;
50468 }
50469 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50470 return resultobj;
50471 fail:
50472 return NULL;
50473 }
50474
50475
50476 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50477 PyObject *resultobj = 0;
50478 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50479 wxSize result;
50480 void *argp1 = 0 ;
50481 int res1 = 0 ;
50482 PyObject *swig_obj[1] ;
50483
50484 if (!args) SWIG_fail;
50485 swig_obj[0] = args;
50486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50487 if (!SWIG_IsOK(res1)) {
50488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50489 }
50490 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50491 {
50492 PyThreadState* __tstate = wxPyBeginAllowThreads();
50493 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50494 wxPyEndAllowThreads(__tstate);
50495 if (PyErr_Occurred()) SWIG_fail;
50496 }
50497 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50498 return resultobj;
50499 fail:
50500 return NULL;
50501 }
50502
50503
50504 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50505 PyObject *resultobj = 0;
50506 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50507 wxSize *arg2 = 0 ;
50508 void *argp1 = 0 ;
50509 int res1 = 0 ;
50510 wxSize temp2 ;
50511 PyObject * obj0 = 0 ;
50512 PyObject * obj1 = 0 ;
50513 char * kwnames[] = {
50514 (char *) "self",(char *) "sz", NULL
50515 };
50516
50517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50519 if (!SWIG_IsOK(res1)) {
50520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50521 }
50522 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50523 {
50524 arg2 = &temp2;
50525 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50526 }
50527 {
50528 PyThreadState* __tstate = wxPyBeginAllowThreads();
50529 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50530 wxPyEndAllowThreads(__tstate);
50531 if (PyErr_Occurred()) SWIG_fail;
50532 }
50533 resultobj = SWIG_Py_Void();
50534 return resultobj;
50535 fail:
50536 return NULL;
50537 }
50538
50539
50540 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50541 PyObject *resultobj = 0;
50542 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50543 wxWindow *arg2 = (wxWindow *) 0 ;
50544 wxGBPosition result;
50545 void *argp1 = 0 ;
50546 int res1 = 0 ;
50547 void *argp2 = 0 ;
50548 int res2 = 0 ;
50549
50550 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50552 if (!SWIG_IsOK(res1)) {
50553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50554 }
50555 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50556 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50557 if (!SWIG_IsOK(res2)) {
50558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50559 }
50560 arg2 = reinterpret_cast< wxWindow * >(argp2);
50561 {
50562 PyThreadState* __tstate = wxPyBeginAllowThreads();
50563 result = (arg1)->GetItemPosition(arg2);
50564 wxPyEndAllowThreads(__tstate);
50565 if (PyErr_Occurred()) SWIG_fail;
50566 }
50567 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50568 return resultobj;
50569 fail:
50570 return NULL;
50571 }
50572
50573
50574 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50575 PyObject *resultobj = 0;
50576 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50577 wxSizer *arg2 = (wxSizer *) 0 ;
50578 wxGBPosition result;
50579 void *argp1 = 0 ;
50580 int res1 = 0 ;
50581 void *argp2 = 0 ;
50582 int res2 = 0 ;
50583
50584 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50586 if (!SWIG_IsOK(res1)) {
50587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50588 }
50589 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50590 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50591 if (!SWIG_IsOK(res2)) {
50592 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50593 }
50594 arg2 = reinterpret_cast< wxSizer * >(argp2);
50595 {
50596 PyThreadState* __tstate = wxPyBeginAllowThreads();
50597 result = (arg1)->GetItemPosition(arg2);
50598 wxPyEndAllowThreads(__tstate);
50599 if (PyErr_Occurred()) SWIG_fail;
50600 }
50601 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50602 return resultobj;
50603 fail:
50604 return NULL;
50605 }
50606
50607
50608 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50609 PyObject *resultobj = 0;
50610 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50611 size_t arg2 ;
50612 wxGBPosition result;
50613 void *argp1 = 0 ;
50614 int res1 = 0 ;
50615 size_t val2 ;
50616 int ecode2 = 0 ;
50617
50618 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50620 if (!SWIG_IsOK(res1)) {
50621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50622 }
50623 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50624 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50625 if (!SWIG_IsOK(ecode2)) {
50626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50627 }
50628 arg2 = static_cast< size_t >(val2);
50629 {
50630 PyThreadState* __tstate = wxPyBeginAllowThreads();
50631 result = (arg1)->GetItemPosition(arg2);
50632 wxPyEndAllowThreads(__tstate);
50633 if (PyErr_Occurred()) SWIG_fail;
50634 }
50635 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50636 return resultobj;
50637 fail:
50638 return NULL;
50639 }
50640
50641
50642 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50643 int argc;
50644 PyObject *argv[3];
50645
50646 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50647 --argc;
50648 if (argc == 2) {
50649 int _v = 0;
50650 {
50651 void *vptr = 0;
50652 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50653 _v = SWIG_CheckState(res);
50654 }
50655 if (!_v) goto check_1;
50656 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50657 }
50658 check_1:
50659
50660 if (argc == 2) {
50661 int _v = 0;
50662 {
50663 void *vptr = 0;
50664 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50665 _v = SWIG_CheckState(res);
50666 }
50667 if (!_v) goto check_2;
50668 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50669 }
50670 check_2:
50671
50672 if (argc == 2) {
50673 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50674 }
50675
50676 fail:
50677 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50678 return NULL;
50679 }
50680
50681
50682 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50683 PyObject *resultobj = 0;
50684 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50685 wxWindow *arg2 = (wxWindow *) 0 ;
50686 wxGBPosition *arg3 = 0 ;
50687 bool result;
50688 void *argp1 = 0 ;
50689 int res1 = 0 ;
50690 void *argp2 = 0 ;
50691 int res2 = 0 ;
50692 wxGBPosition temp3 ;
50693
50694 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50696 if (!SWIG_IsOK(res1)) {
50697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50698 }
50699 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50700 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50701 if (!SWIG_IsOK(res2)) {
50702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50703 }
50704 arg2 = reinterpret_cast< wxWindow * >(argp2);
50705 {
50706 arg3 = &temp3;
50707 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50708 }
50709 {
50710 PyThreadState* __tstate = wxPyBeginAllowThreads();
50711 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50712 wxPyEndAllowThreads(__tstate);
50713 if (PyErr_Occurred()) SWIG_fail;
50714 }
50715 {
50716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50717 }
50718 return resultobj;
50719 fail:
50720 return NULL;
50721 }
50722
50723
50724 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50725 PyObject *resultobj = 0;
50726 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50727 wxSizer *arg2 = (wxSizer *) 0 ;
50728 wxGBPosition *arg3 = 0 ;
50729 bool result;
50730 void *argp1 = 0 ;
50731 int res1 = 0 ;
50732 void *argp2 = 0 ;
50733 int res2 = 0 ;
50734 wxGBPosition temp3 ;
50735
50736 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50738 if (!SWIG_IsOK(res1)) {
50739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50740 }
50741 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50742 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50743 if (!SWIG_IsOK(res2)) {
50744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50745 }
50746 arg2 = reinterpret_cast< wxSizer * >(argp2);
50747 {
50748 arg3 = &temp3;
50749 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50750 }
50751 {
50752 PyThreadState* __tstate = wxPyBeginAllowThreads();
50753 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50754 wxPyEndAllowThreads(__tstate);
50755 if (PyErr_Occurred()) SWIG_fail;
50756 }
50757 {
50758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50759 }
50760 return resultobj;
50761 fail:
50762 return NULL;
50763 }
50764
50765
50766 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50767 PyObject *resultobj = 0;
50768 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50769 size_t arg2 ;
50770 wxGBPosition *arg3 = 0 ;
50771 bool result;
50772 void *argp1 = 0 ;
50773 int res1 = 0 ;
50774 size_t val2 ;
50775 int ecode2 = 0 ;
50776 wxGBPosition temp3 ;
50777
50778 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50780 if (!SWIG_IsOK(res1)) {
50781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50782 }
50783 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50784 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50785 if (!SWIG_IsOK(ecode2)) {
50786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50787 }
50788 arg2 = static_cast< size_t >(val2);
50789 {
50790 arg3 = &temp3;
50791 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50792 }
50793 {
50794 PyThreadState* __tstate = wxPyBeginAllowThreads();
50795 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50796 wxPyEndAllowThreads(__tstate);
50797 if (PyErr_Occurred()) SWIG_fail;
50798 }
50799 {
50800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50801 }
50802 return resultobj;
50803 fail:
50804 return NULL;
50805 }
50806
50807
50808 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50809 int argc;
50810 PyObject *argv[4];
50811
50812 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50813 --argc;
50814 if (argc == 3) {
50815 int _v = 0;
50816 {
50817 void *vptr = 0;
50818 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50819 _v = SWIG_CheckState(res);
50820 }
50821 if (!_v) goto check_1;
50822 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50823 }
50824 check_1:
50825
50826 if (argc == 3) {
50827 int _v = 0;
50828 {
50829 void *vptr = 0;
50830 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50831 _v = SWIG_CheckState(res);
50832 }
50833 if (!_v) goto check_2;
50834 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50835 }
50836 check_2:
50837
50838 if (argc == 3) {
50839 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50840 }
50841
50842 fail:
50843 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50844 return NULL;
50845 }
50846
50847
50848 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50849 PyObject *resultobj = 0;
50850 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50851 wxWindow *arg2 = (wxWindow *) 0 ;
50852 wxGBSpan result;
50853 void *argp1 = 0 ;
50854 int res1 = 0 ;
50855 void *argp2 = 0 ;
50856 int res2 = 0 ;
50857
50858 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50860 if (!SWIG_IsOK(res1)) {
50861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50862 }
50863 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50864 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50865 if (!SWIG_IsOK(res2)) {
50866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50867 }
50868 arg2 = reinterpret_cast< wxWindow * >(argp2);
50869 {
50870 PyThreadState* __tstate = wxPyBeginAllowThreads();
50871 result = (arg1)->GetItemSpan(arg2);
50872 wxPyEndAllowThreads(__tstate);
50873 if (PyErr_Occurred()) SWIG_fail;
50874 }
50875 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50876 return resultobj;
50877 fail:
50878 return NULL;
50879 }
50880
50881
50882 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50883 PyObject *resultobj = 0;
50884 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50885 wxSizer *arg2 = (wxSizer *) 0 ;
50886 wxGBSpan result;
50887 void *argp1 = 0 ;
50888 int res1 = 0 ;
50889 void *argp2 = 0 ;
50890 int res2 = 0 ;
50891
50892 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50894 if (!SWIG_IsOK(res1)) {
50895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50896 }
50897 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50898 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50899 if (!SWIG_IsOK(res2)) {
50900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50901 }
50902 arg2 = reinterpret_cast< wxSizer * >(argp2);
50903 {
50904 PyThreadState* __tstate = wxPyBeginAllowThreads();
50905 result = (arg1)->GetItemSpan(arg2);
50906 wxPyEndAllowThreads(__tstate);
50907 if (PyErr_Occurred()) SWIG_fail;
50908 }
50909 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50910 return resultobj;
50911 fail:
50912 return NULL;
50913 }
50914
50915
50916 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50917 PyObject *resultobj = 0;
50918 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50919 size_t arg2 ;
50920 wxGBSpan result;
50921 void *argp1 = 0 ;
50922 int res1 = 0 ;
50923 size_t val2 ;
50924 int ecode2 = 0 ;
50925
50926 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50928 if (!SWIG_IsOK(res1)) {
50929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50930 }
50931 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50932 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50933 if (!SWIG_IsOK(ecode2)) {
50934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50935 }
50936 arg2 = static_cast< size_t >(val2);
50937 {
50938 PyThreadState* __tstate = wxPyBeginAllowThreads();
50939 result = (arg1)->GetItemSpan(arg2);
50940 wxPyEndAllowThreads(__tstate);
50941 if (PyErr_Occurred()) SWIG_fail;
50942 }
50943 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50944 return resultobj;
50945 fail:
50946 return NULL;
50947 }
50948
50949
50950 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50951 int argc;
50952 PyObject *argv[3];
50953
50954 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50955 --argc;
50956 if (argc == 2) {
50957 int _v = 0;
50958 {
50959 void *vptr = 0;
50960 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50961 _v = SWIG_CheckState(res);
50962 }
50963 if (!_v) goto check_1;
50964 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50965 }
50966 check_1:
50967
50968 if (argc == 2) {
50969 int _v = 0;
50970 {
50971 void *vptr = 0;
50972 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50973 _v = SWIG_CheckState(res);
50974 }
50975 if (!_v) goto check_2;
50976 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50977 }
50978 check_2:
50979
50980 if (argc == 2) {
50981 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50982 }
50983
50984 fail:
50985 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50986 return NULL;
50987 }
50988
50989
50990 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50991 PyObject *resultobj = 0;
50992 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50993 wxWindow *arg2 = (wxWindow *) 0 ;
50994 wxGBSpan *arg3 = 0 ;
50995 bool result;
50996 void *argp1 = 0 ;
50997 int res1 = 0 ;
50998 void *argp2 = 0 ;
50999 int res2 = 0 ;
51000 wxGBSpan temp3 ;
51001
51002 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51004 if (!SWIG_IsOK(res1)) {
51005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51006 }
51007 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51008 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51009 if (!SWIG_IsOK(res2)) {
51010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51011 }
51012 arg2 = reinterpret_cast< wxWindow * >(argp2);
51013 {
51014 arg3 = &temp3;
51015 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51016 }
51017 {
51018 PyThreadState* __tstate = wxPyBeginAllowThreads();
51019 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51020 wxPyEndAllowThreads(__tstate);
51021 if (PyErr_Occurred()) SWIG_fail;
51022 }
51023 {
51024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51025 }
51026 return resultobj;
51027 fail:
51028 return NULL;
51029 }
51030
51031
51032 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51033 PyObject *resultobj = 0;
51034 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51035 wxSizer *arg2 = (wxSizer *) 0 ;
51036 wxGBSpan *arg3 = 0 ;
51037 bool result;
51038 void *argp1 = 0 ;
51039 int res1 = 0 ;
51040 void *argp2 = 0 ;
51041 int res2 = 0 ;
51042 wxGBSpan temp3 ;
51043
51044 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51046 if (!SWIG_IsOK(res1)) {
51047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51048 }
51049 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51050 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51051 if (!SWIG_IsOK(res2)) {
51052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51053 }
51054 arg2 = reinterpret_cast< wxSizer * >(argp2);
51055 {
51056 arg3 = &temp3;
51057 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51058 }
51059 {
51060 PyThreadState* __tstate = wxPyBeginAllowThreads();
51061 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51062 wxPyEndAllowThreads(__tstate);
51063 if (PyErr_Occurred()) SWIG_fail;
51064 }
51065 {
51066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51067 }
51068 return resultobj;
51069 fail:
51070 return NULL;
51071 }
51072
51073
51074 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51075 PyObject *resultobj = 0;
51076 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51077 size_t arg2 ;
51078 wxGBSpan *arg3 = 0 ;
51079 bool result;
51080 void *argp1 = 0 ;
51081 int res1 = 0 ;
51082 size_t val2 ;
51083 int ecode2 = 0 ;
51084 wxGBSpan temp3 ;
51085
51086 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51088 if (!SWIG_IsOK(res1)) {
51089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51090 }
51091 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51092 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51093 if (!SWIG_IsOK(ecode2)) {
51094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51095 }
51096 arg2 = static_cast< size_t >(val2);
51097 {
51098 arg3 = &temp3;
51099 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51100 }
51101 {
51102 PyThreadState* __tstate = wxPyBeginAllowThreads();
51103 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51104 wxPyEndAllowThreads(__tstate);
51105 if (PyErr_Occurred()) SWIG_fail;
51106 }
51107 {
51108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51109 }
51110 return resultobj;
51111 fail:
51112 return NULL;
51113 }
51114
51115
51116 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51117 int argc;
51118 PyObject *argv[4];
51119
51120 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51121 --argc;
51122 if (argc == 3) {
51123 int _v = 0;
51124 {
51125 void *vptr = 0;
51126 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51127 _v = SWIG_CheckState(res);
51128 }
51129 if (!_v) goto check_1;
51130 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51131 }
51132 check_1:
51133
51134 if (argc == 3) {
51135 int _v = 0;
51136 {
51137 void *vptr = 0;
51138 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51139 _v = SWIG_CheckState(res);
51140 }
51141 if (!_v) goto check_2;
51142 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51143 }
51144 check_2:
51145
51146 if (argc == 3) {
51147 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51148 }
51149
51150 fail:
51151 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51152 return NULL;
51153 }
51154
51155
51156 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51157 PyObject *resultobj = 0;
51158 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51159 wxWindow *arg2 = (wxWindow *) 0 ;
51160 wxGBSizerItem *result = 0 ;
51161 void *argp1 = 0 ;
51162 int res1 = 0 ;
51163 void *argp2 = 0 ;
51164 int res2 = 0 ;
51165
51166 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51168 if (!SWIG_IsOK(res1)) {
51169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51170 }
51171 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51172 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51173 if (!SWIG_IsOK(res2)) {
51174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51175 }
51176 arg2 = reinterpret_cast< wxWindow * >(argp2);
51177 {
51178 PyThreadState* __tstate = wxPyBeginAllowThreads();
51179 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51180 wxPyEndAllowThreads(__tstate);
51181 if (PyErr_Occurred()) SWIG_fail;
51182 }
51183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51184 return resultobj;
51185 fail:
51186 return NULL;
51187 }
51188
51189
51190 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51191 PyObject *resultobj = 0;
51192 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51193 wxSizer *arg2 = (wxSizer *) 0 ;
51194 wxGBSizerItem *result = 0 ;
51195 void *argp1 = 0 ;
51196 int res1 = 0 ;
51197 void *argp2 = 0 ;
51198 int res2 = 0 ;
51199
51200 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51202 if (!SWIG_IsOK(res1)) {
51203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51204 }
51205 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51206 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51207 if (!SWIG_IsOK(res2)) {
51208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51209 }
51210 arg2 = reinterpret_cast< wxSizer * >(argp2);
51211 {
51212 PyThreadState* __tstate = wxPyBeginAllowThreads();
51213 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51214 wxPyEndAllowThreads(__tstate);
51215 if (PyErr_Occurred()) SWIG_fail;
51216 }
51217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51218 return resultobj;
51219 fail:
51220 return NULL;
51221 }
51222
51223
51224 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51225 int argc;
51226 PyObject *argv[3];
51227
51228 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51229 --argc;
51230 if (argc == 2) {
51231 int _v = 0;
51232 {
51233 void *vptr = 0;
51234 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51235 _v = SWIG_CheckState(res);
51236 }
51237 if (!_v) goto check_1;
51238 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51239 }
51240 check_1:
51241
51242 if (argc == 2) {
51243 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51244 }
51245
51246 fail:
51247 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51248 return NULL;
51249 }
51250
51251
51252 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51253 PyObject *resultobj = 0;
51254 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51255 wxGBPosition *arg2 = 0 ;
51256 wxGBSizerItem *result = 0 ;
51257 void *argp1 = 0 ;
51258 int res1 = 0 ;
51259 wxGBPosition temp2 ;
51260 PyObject * obj0 = 0 ;
51261 PyObject * obj1 = 0 ;
51262 char * kwnames[] = {
51263 (char *) "self",(char *) "pos", NULL
51264 };
51265
51266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51268 if (!SWIG_IsOK(res1)) {
51269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51270 }
51271 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51272 {
51273 arg2 = &temp2;
51274 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51275 }
51276 {
51277 PyThreadState* __tstate = wxPyBeginAllowThreads();
51278 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51279 wxPyEndAllowThreads(__tstate);
51280 if (PyErr_Occurred()) SWIG_fail;
51281 }
51282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51283 return resultobj;
51284 fail:
51285 return NULL;
51286 }
51287
51288
51289 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51290 PyObject *resultobj = 0;
51291 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51292 wxPoint *arg2 = 0 ;
51293 wxGBSizerItem *result = 0 ;
51294 void *argp1 = 0 ;
51295 int res1 = 0 ;
51296 wxPoint temp2 ;
51297 PyObject * obj0 = 0 ;
51298 PyObject * obj1 = 0 ;
51299 char * kwnames[] = {
51300 (char *) "self",(char *) "pt", NULL
51301 };
51302
51303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51305 if (!SWIG_IsOK(res1)) {
51306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51307 }
51308 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51309 {
51310 arg2 = &temp2;
51311 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51312 }
51313 {
51314 PyThreadState* __tstate = wxPyBeginAllowThreads();
51315 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51316 wxPyEndAllowThreads(__tstate);
51317 if (PyErr_Occurred()) SWIG_fail;
51318 }
51319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51320 return resultobj;
51321 fail:
51322 return NULL;
51323 }
51324
51325
51326 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51327 PyObject *resultobj = 0;
51328 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51329 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51330 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51331 bool result;
51332 void *argp1 = 0 ;
51333 int res1 = 0 ;
51334 void *argp2 = 0 ;
51335 int res2 = 0 ;
51336 void *argp3 = 0 ;
51337 int res3 = 0 ;
51338 PyObject * obj0 = 0 ;
51339 PyObject * obj1 = 0 ;
51340 PyObject * obj2 = 0 ;
51341 char * kwnames[] = {
51342 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51343 };
51344
51345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51347 if (!SWIG_IsOK(res1)) {
51348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51349 }
51350 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51351 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51352 if (!SWIG_IsOK(res2)) {
51353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51354 }
51355 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51356 if (obj2) {
51357 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51358 if (!SWIG_IsOK(res3)) {
51359 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51360 }
51361 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51362 }
51363 {
51364 PyThreadState* __tstate = wxPyBeginAllowThreads();
51365 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51366 wxPyEndAllowThreads(__tstate);
51367 if (PyErr_Occurred()) SWIG_fail;
51368 }
51369 {
51370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51371 }
51372 return resultobj;
51373 fail:
51374 return NULL;
51375 }
51376
51377
51378 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51379 PyObject *resultobj = 0;
51380 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51381 wxGBPosition *arg2 = 0 ;
51382 wxGBSpan *arg3 = 0 ;
51383 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51384 bool result;
51385 void *argp1 = 0 ;
51386 int res1 = 0 ;
51387 wxGBPosition temp2 ;
51388 wxGBSpan temp3 ;
51389 void *argp4 = 0 ;
51390 int res4 = 0 ;
51391 PyObject * obj0 = 0 ;
51392 PyObject * obj1 = 0 ;
51393 PyObject * obj2 = 0 ;
51394 PyObject * obj3 = 0 ;
51395 char * kwnames[] = {
51396 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51397 };
51398
51399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51401 if (!SWIG_IsOK(res1)) {
51402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51403 }
51404 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51405 {
51406 arg2 = &temp2;
51407 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51408 }
51409 {
51410 arg3 = &temp3;
51411 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51412 }
51413 if (obj3) {
51414 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51415 if (!SWIG_IsOK(res4)) {
51416 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51417 }
51418 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51419 }
51420 {
51421 PyThreadState* __tstate = wxPyBeginAllowThreads();
51422 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51423 wxPyEndAllowThreads(__tstate);
51424 if (PyErr_Occurred()) SWIG_fail;
51425 }
51426 {
51427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51428 }
51429 return resultobj;
51430 fail:
51431 return NULL;
51432 }
51433
51434
51435 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51436 PyObject *obj;
51437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51438 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51439 return SWIG_Py_Void();
51440 }
51441
51442 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51443 return SWIG_Python_InitShadowInstance(args);
51444 }
51445
51446 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51447 PyObject *resultobj = 0;
51448 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51449 wxRelationship arg2 ;
51450 wxWindow *arg3 = (wxWindow *) 0 ;
51451 wxEdge arg4 ;
51452 int arg5 = (int) 0 ;
51453 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51454 void *argp1 = 0 ;
51455 int res1 = 0 ;
51456 int val2 ;
51457 int ecode2 = 0 ;
51458 void *argp3 = 0 ;
51459 int res3 = 0 ;
51460 int val4 ;
51461 int ecode4 = 0 ;
51462 int val5 ;
51463 int ecode5 = 0 ;
51464 int val6 ;
51465 int ecode6 = 0 ;
51466 PyObject * obj0 = 0 ;
51467 PyObject * obj1 = 0 ;
51468 PyObject * obj2 = 0 ;
51469 PyObject * obj3 = 0 ;
51470 PyObject * obj4 = 0 ;
51471 PyObject * obj5 = 0 ;
51472 char * kwnames[] = {
51473 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51474 };
51475
51476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51478 if (!SWIG_IsOK(res1)) {
51479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51480 }
51481 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51482 ecode2 = SWIG_AsVal_int(obj1, &val2);
51483 if (!SWIG_IsOK(ecode2)) {
51484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51485 }
51486 arg2 = static_cast< wxRelationship >(val2);
51487 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51488 if (!SWIG_IsOK(res3)) {
51489 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51490 }
51491 arg3 = reinterpret_cast< wxWindow * >(argp3);
51492 ecode4 = SWIG_AsVal_int(obj3, &val4);
51493 if (!SWIG_IsOK(ecode4)) {
51494 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51495 }
51496 arg4 = static_cast< wxEdge >(val4);
51497 if (obj4) {
51498 ecode5 = SWIG_AsVal_int(obj4, &val5);
51499 if (!SWIG_IsOK(ecode5)) {
51500 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51501 }
51502 arg5 = static_cast< int >(val5);
51503 }
51504 if (obj5) {
51505 ecode6 = SWIG_AsVal_int(obj5, &val6);
51506 if (!SWIG_IsOK(ecode6)) {
51507 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51508 }
51509 arg6 = static_cast< int >(val6);
51510 }
51511 {
51512 PyThreadState* __tstate = wxPyBeginAllowThreads();
51513 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51514 wxPyEndAllowThreads(__tstate);
51515 if (PyErr_Occurred()) SWIG_fail;
51516 }
51517 resultobj = SWIG_Py_Void();
51518 return resultobj;
51519 fail:
51520 return NULL;
51521 }
51522
51523
51524 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51525 PyObject *resultobj = 0;
51526 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51527 wxWindow *arg2 = (wxWindow *) 0 ;
51528 int arg3 = (int) 0 ;
51529 void *argp1 = 0 ;
51530 int res1 = 0 ;
51531 void *argp2 = 0 ;
51532 int res2 = 0 ;
51533 int val3 ;
51534 int ecode3 = 0 ;
51535 PyObject * obj0 = 0 ;
51536 PyObject * obj1 = 0 ;
51537 PyObject * obj2 = 0 ;
51538 char * kwnames[] = {
51539 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51540 };
51541
51542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51544 if (!SWIG_IsOK(res1)) {
51545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51546 }
51547 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51548 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51549 if (!SWIG_IsOK(res2)) {
51550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51551 }
51552 arg2 = reinterpret_cast< wxWindow * >(argp2);
51553 if (obj2) {
51554 ecode3 = SWIG_AsVal_int(obj2, &val3);
51555 if (!SWIG_IsOK(ecode3)) {
51556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51557 }
51558 arg3 = static_cast< int >(val3);
51559 }
51560 {
51561 PyThreadState* __tstate = wxPyBeginAllowThreads();
51562 (arg1)->LeftOf(arg2,arg3);
51563 wxPyEndAllowThreads(__tstate);
51564 if (PyErr_Occurred()) SWIG_fail;
51565 }
51566 resultobj = SWIG_Py_Void();
51567 return resultobj;
51568 fail:
51569 return NULL;
51570 }
51571
51572
51573 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51574 PyObject *resultobj = 0;
51575 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51576 wxWindow *arg2 = (wxWindow *) 0 ;
51577 int arg3 = (int) 0 ;
51578 void *argp1 = 0 ;
51579 int res1 = 0 ;
51580 void *argp2 = 0 ;
51581 int res2 = 0 ;
51582 int val3 ;
51583 int ecode3 = 0 ;
51584 PyObject * obj0 = 0 ;
51585 PyObject * obj1 = 0 ;
51586 PyObject * obj2 = 0 ;
51587 char * kwnames[] = {
51588 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51589 };
51590
51591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51593 if (!SWIG_IsOK(res1)) {
51594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51595 }
51596 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51597 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51598 if (!SWIG_IsOK(res2)) {
51599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51600 }
51601 arg2 = reinterpret_cast< wxWindow * >(argp2);
51602 if (obj2) {
51603 ecode3 = SWIG_AsVal_int(obj2, &val3);
51604 if (!SWIG_IsOK(ecode3)) {
51605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51606 }
51607 arg3 = static_cast< int >(val3);
51608 }
51609 {
51610 PyThreadState* __tstate = wxPyBeginAllowThreads();
51611 (arg1)->RightOf(arg2,arg3);
51612 wxPyEndAllowThreads(__tstate);
51613 if (PyErr_Occurred()) SWIG_fail;
51614 }
51615 resultobj = SWIG_Py_Void();
51616 return resultobj;
51617 fail:
51618 return NULL;
51619 }
51620
51621
51622 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51623 PyObject *resultobj = 0;
51624 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51625 wxWindow *arg2 = (wxWindow *) 0 ;
51626 int arg3 = (int) 0 ;
51627 void *argp1 = 0 ;
51628 int res1 = 0 ;
51629 void *argp2 = 0 ;
51630 int res2 = 0 ;
51631 int val3 ;
51632 int ecode3 = 0 ;
51633 PyObject * obj0 = 0 ;
51634 PyObject * obj1 = 0 ;
51635 PyObject * obj2 = 0 ;
51636 char * kwnames[] = {
51637 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51638 };
51639
51640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51642 if (!SWIG_IsOK(res1)) {
51643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51644 }
51645 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51646 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51647 if (!SWIG_IsOK(res2)) {
51648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51649 }
51650 arg2 = reinterpret_cast< wxWindow * >(argp2);
51651 if (obj2) {
51652 ecode3 = SWIG_AsVal_int(obj2, &val3);
51653 if (!SWIG_IsOK(ecode3)) {
51654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51655 }
51656 arg3 = static_cast< int >(val3);
51657 }
51658 {
51659 PyThreadState* __tstate = wxPyBeginAllowThreads();
51660 (arg1)->Above(arg2,arg3);
51661 wxPyEndAllowThreads(__tstate);
51662 if (PyErr_Occurred()) SWIG_fail;
51663 }
51664 resultobj = SWIG_Py_Void();
51665 return resultobj;
51666 fail:
51667 return NULL;
51668 }
51669
51670
51671 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51672 PyObject *resultobj = 0;
51673 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51674 wxWindow *arg2 = (wxWindow *) 0 ;
51675 int arg3 = (int) 0 ;
51676 void *argp1 = 0 ;
51677 int res1 = 0 ;
51678 void *argp2 = 0 ;
51679 int res2 = 0 ;
51680 int val3 ;
51681 int ecode3 = 0 ;
51682 PyObject * obj0 = 0 ;
51683 PyObject * obj1 = 0 ;
51684 PyObject * obj2 = 0 ;
51685 char * kwnames[] = {
51686 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51687 };
51688
51689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51691 if (!SWIG_IsOK(res1)) {
51692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51693 }
51694 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51695 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51696 if (!SWIG_IsOK(res2)) {
51697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51698 }
51699 arg2 = reinterpret_cast< wxWindow * >(argp2);
51700 if (obj2) {
51701 ecode3 = SWIG_AsVal_int(obj2, &val3);
51702 if (!SWIG_IsOK(ecode3)) {
51703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51704 }
51705 arg3 = static_cast< int >(val3);
51706 }
51707 {
51708 PyThreadState* __tstate = wxPyBeginAllowThreads();
51709 (arg1)->Below(arg2,arg3);
51710 wxPyEndAllowThreads(__tstate);
51711 if (PyErr_Occurred()) SWIG_fail;
51712 }
51713 resultobj = SWIG_Py_Void();
51714 return resultobj;
51715 fail:
51716 return NULL;
51717 }
51718
51719
51720 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51721 PyObject *resultobj = 0;
51722 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51723 wxWindow *arg2 = (wxWindow *) 0 ;
51724 wxEdge arg3 ;
51725 int arg4 = (int) 0 ;
51726 void *argp1 = 0 ;
51727 int res1 = 0 ;
51728 void *argp2 = 0 ;
51729 int res2 = 0 ;
51730 int val3 ;
51731 int ecode3 = 0 ;
51732 int val4 ;
51733 int ecode4 = 0 ;
51734 PyObject * obj0 = 0 ;
51735 PyObject * obj1 = 0 ;
51736 PyObject * obj2 = 0 ;
51737 PyObject * obj3 = 0 ;
51738 char * kwnames[] = {
51739 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51740 };
51741
51742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51744 if (!SWIG_IsOK(res1)) {
51745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51746 }
51747 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51748 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51749 if (!SWIG_IsOK(res2)) {
51750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51751 }
51752 arg2 = reinterpret_cast< wxWindow * >(argp2);
51753 ecode3 = SWIG_AsVal_int(obj2, &val3);
51754 if (!SWIG_IsOK(ecode3)) {
51755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51756 }
51757 arg3 = static_cast< wxEdge >(val3);
51758 if (obj3) {
51759 ecode4 = SWIG_AsVal_int(obj3, &val4);
51760 if (!SWIG_IsOK(ecode4)) {
51761 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51762 }
51763 arg4 = static_cast< int >(val4);
51764 }
51765 {
51766 PyThreadState* __tstate = wxPyBeginAllowThreads();
51767 (arg1)->SameAs(arg2,arg3,arg4);
51768 wxPyEndAllowThreads(__tstate);
51769 if (PyErr_Occurred()) SWIG_fail;
51770 }
51771 resultobj = SWIG_Py_Void();
51772 return resultobj;
51773 fail:
51774 return NULL;
51775 }
51776
51777
51778 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51779 PyObject *resultobj = 0;
51780 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51781 wxWindow *arg2 = (wxWindow *) 0 ;
51782 wxEdge arg3 ;
51783 int arg4 ;
51784 void *argp1 = 0 ;
51785 int res1 = 0 ;
51786 void *argp2 = 0 ;
51787 int res2 = 0 ;
51788 int val3 ;
51789 int ecode3 = 0 ;
51790 int val4 ;
51791 int ecode4 = 0 ;
51792 PyObject * obj0 = 0 ;
51793 PyObject * obj1 = 0 ;
51794 PyObject * obj2 = 0 ;
51795 PyObject * obj3 = 0 ;
51796 char * kwnames[] = {
51797 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51798 };
51799
51800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51802 if (!SWIG_IsOK(res1)) {
51803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51804 }
51805 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51806 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51807 if (!SWIG_IsOK(res2)) {
51808 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51809 }
51810 arg2 = reinterpret_cast< wxWindow * >(argp2);
51811 ecode3 = SWIG_AsVal_int(obj2, &val3);
51812 if (!SWIG_IsOK(ecode3)) {
51813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51814 }
51815 arg3 = static_cast< wxEdge >(val3);
51816 ecode4 = SWIG_AsVal_int(obj3, &val4);
51817 if (!SWIG_IsOK(ecode4)) {
51818 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51819 }
51820 arg4 = static_cast< int >(val4);
51821 {
51822 PyThreadState* __tstate = wxPyBeginAllowThreads();
51823 (arg1)->PercentOf(arg2,arg3,arg4);
51824 wxPyEndAllowThreads(__tstate);
51825 if (PyErr_Occurred()) SWIG_fail;
51826 }
51827 resultobj = SWIG_Py_Void();
51828 return resultobj;
51829 fail:
51830 return NULL;
51831 }
51832
51833
51834 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51835 PyObject *resultobj = 0;
51836 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51837 int arg2 ;
51838 void *argp1 = 0 ;
51839 int res1 = 0 ;
51840 int val2 ;
51841 int ecode2 = 0 ;
51842 PyObject * obj0 = 0 ;
51843 PyObject * obj1 = 0 ;
51844 char * kwnames[] = {
51845 (char *) "self",(char *) "val", NULL
51846 };
51847
51848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51850 if (!SWIG_IsOK(res1)) {
51851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51852 }
51853 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51854 ecode2 = SWIG_AsVal_int(obj1, &val2);
51855 if (!SWIG_IsOK(ecode2)) {
51856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51857 }
51858 arg2 = static_cast< int >(val2);
51859 {
51860 PyThreadState* __tstate = wxPyBeginAllowThreads();
51861 (arg1)->Absolute(arg2);
51862 wxPyEndAllowThreads(__tstate);
51863 if (PyErr_Occurred()) SWIG_fail;
51864 }
51865 resultobj = SWIG_Py_Void();
51866 return resultobj;
51867 fail:
51868 return NULL;
51869 }
51870
51871
51872 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51873 PyObject *resultobj = 0;
51874 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51875 void *argp1 = 0 ;
51876 int res1 = 0 ;
51877 PyObject *swig_obj[1] ;
51878
51879 if (!args) SWIG_fail;
51880 swig_obj[0] = args;
51881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51882 if (!SWIG_IsOK(res1)) {
51883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51884 }
51885 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51886 {
51887 PyThreadState* __tstate = wxPyBeginAllowThreads();
51888 (arg1)->Unconstrained();
51889 wxPyEndAllowThreads(__tstate);
51890 if (PyErr_Occurred()) SWIG_fail;
51891 }
51892 resultobj = SWIG_Py_Void();
51893 return resultobj;
51894 fail:
51895 return NULL;
51896 }
51897
51898
51899 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51900 PyObject *resultobj = 0;
51901 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51902 void *argp1 = 0 ;
51903 int res1 = 0 ;
51904 PyObject *swig_obj[1] ;
51905
51906 if (!args) SWIG_fail;
51907 swig_obj[0] = args;
51908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51909 if (!SWIG_IsOK(res1)) {
51910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51911 }
51912 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51913 {
51914 PyThreadState* __tstate = wxPyBeginAllowThreads();
51915 (arg1)->AsIs();
51916 wxPyEndAllowThreads(__tstate);
51917 if (PyErr_Occurred()) SWIG_fail;
51918 }
51919 resultobj = SWIG_Py_Void();
51920 return resultobj;
51921 fail:
51922 return NULL;
51923 }
51924
51925
51926 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51927 PyObject *resultobj = 0;
51928 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51929 wxWindow *result = 0 ;
51930 void *argp1 = 0 ;
51931 int res1 = 0 ;
51932 PyObject *swig_obj[1] ;
51933
51934 if (!args) SWIG_fail;
51935 swig_obj[0] = args;
51936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51937 if (!SWIG_IsOK(res1)) {
51938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51939 }
51940 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51941 {
51942 PyThreadState* __tstate = wxPyBeginAllowThreads();
51943 result = (wxWindow *)(arg1)->GetOtherWindow();
51944 wxPyEndAllowThreads(__tstate);
51945 if (PyErr_Occurred()) SWIG_fail;
51946 }
51947 {
51948 resultobj = wxPyMake_wxObject(result, 0);
51949 }
51950 return resultobj;
51951 fail:
51952 return NULL;
51953 }
51954
51955
51956 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51957 PyObject *resultobj = 0;
51958 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51959 wxEdge result;
51960 void *argp1 = 0 ;
51961 int res1 = 0 ;
51962 PyObject *swig_obj[1] ;
51963
51964 if (!args) SWIG_fail;
51965 swig_obj[0] = args;
51966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51967 if (!SWIG_IsOK(res1)) {
51968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51969 }
51970 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51971 {
51972 PyThreadState* __tstate = wxPyBeginAllowThreads();
51973 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51974 wxPyEndAllowThreads(__tstate);
51975 if (PyErr_Occurred()) SWIG_fail;
51976 }
51977 resultobj = SWIG_From_int(static_cast< int >(result));
51978 return resultobj;
51979 fail:
51980 return NULL;
51981 }
51982
51983
51984 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51985 PyObject *resultobj = 0;
51986 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51987 wxEdge arg2 ;
51988 void *argp1 = 0 ;
51989 int res1 = 0 ;
51990 int val2 ;
51991 int ecode2 = 0 ;
51992 PyObject * obj0 = 0 ;
51993 PyObject * obj1 = 0 ;
51994 char * kwnames[] = {
51995 (char *) "self",(char *) "which", NULL
51996 };
51997
51998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52000 if (!SWIG_IsOK(res1)) {
52001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52002 }
52003 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52004 ecode2 = SWIG_AsVal_int(obj1, &val2);
52005 if (!SWIG_IsOK(ecode2)) {
52006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52007 }
52008 arg2 = static_cast< wxEdge >(val2);
52009 {
52010 PyThreadState* __tstate = wxPyBeginAllowThreads();
52011 (arg1)->SetEdge(arg2);
52012 wxPyEndAllowThreads(__tstate);
52013 if (PyErr_Occurred()) SWIG_fail;
52014 }
52015 resultobj = SWIG_Py_Void();
52016 return resultobj;
52017 fail:
52018 return NULL;
52019 }
52020
52021
52022 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52023 PyObject *resultobj = 0;
52024 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52025 int arg2 ;
52026 void *argp1 = 0 ;
52027 int res1 = 0 ;
52028 int val2 ;
52029 int ecode2 = 0 ;
52030 PyObject * obj0 = 0 ;
52031 PyObject * obj1 = 0 ;
52032 char * kwnames[] = {
52033 (char *) "self",(char *) "v", NULL
52034 };
52035
52036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52038 if (!SWIG_IsOK(res1)) {
52039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52040 }
52041 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52042 ecode2 = SWIG_AsVal_int(obj1, &val2);
52043 if (!SWIG_IsOK(ecode2)) {
52044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52045 }
52046 arg2 = static_cast< int >(val2);
52047 {
52048 PyThreadState* __tstate = wxPyBeginAllowThreads();
52049 (arg1)->SetValue(arg2);
52050 wxPyEndAllowThreads(__tstate);
52051 if (PyErr_Occurred()) SWIG_fail;
52052 }
52053 resultobj = SWIG_Py_Void();
52054 return resultobj;
52055 fail:
52056 return NULL;
52057 }
52058
52059
52060 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52061 PyObject *resultobj = 0;
52062 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52063 int result;
52064 void *argp1 = 0 ;
52065 int res1 = 0 ;
52066 PyObject *swig_obj[1] ;
52067
52068 if (!args) SWIG_fail;
52069 swig_obj[0] = args;
52070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52071 if (!SWIG_IsOK(res1)) {
52072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52073 }
52074 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52075 {
52076 PyThreadState* __tstate = wxPyBeginAllowThreads();
52077 result = (int)(arg1)->GetMargin();
52078 wxPyEndAllowThreads(__tstate);
52079 if (PyErr_Occurred()) SWIG_fail;
52080 }
52081 resultobj = SWIG_From_int(static_cast< int >(result));
52082 return resultobj;
52083 fail:
52084 return NULL;
52085 }
52086
52087
52088 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52089 PyObject *resultobj = 0;
52090 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52091 int arg2 ;
52092 void *argp1 = 0 ;
52093 int res1 = 0 ;
52094 int val2 ;
52095 int ecode2 = 0 ;
52096 PyObject * obj0 = 0 ;
52097 PyObject * obj1 = 0 ;
52098 char * kwnames[] = {
52099 (char *) "self",(char *) "m", NULL
52100 };
52101
52102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52104 if (!SWIG_IsOK(res1)) {
52105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52106 }
52107 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52108 ecode2 = SWIG_AsVal_int(obj1, &val2);
52109 if (!SWIG_IsOK(ecode2)) {
52110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52111 }
52112 arg2 = static_cast< int >(val2);
52113 {
52114 PyThreadState* __tstate = wxPyBeginAllowThreads();
52115 (arg1)->SetMargin(arg2);
52116 wxPyEndAllowThreads(__tstate);
52117 if (PyErr_Occurred()) SWIG_fail;
52118 }
52119 resultobj = SWIG_Py_Void();
52120 return resultobj;
52121 fail:
52122 return NULL;
52123 }
52124
52125
52126 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52127 PyObject *resultobj = 0;
52128 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52129 int result;
52130 void *argp1 = 0 ;
52131 int res1 = 0 ;
52132 PyObject *swig_obj[1] ;
52133
52134 if (!args) SWIG_fail;
52135 swig_obj[0] = args;
52136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52137 if (!SWIG_IsOK(res1)) {
52138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52139 }
52140 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52141 {
52142 PyThreadState* __tstate = wxPyBeginAllowThreads();
52143 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52144 wxPyEndAllowThreads(__tstate);
52145 if (PyErr_Occurred()) SWIG_fail;
52146 }
52147 resultobj = SWIG_From_int(static_cast< int >(result));
52148 return resultobj;
52149 fail:
52150 return NULL;
52151 }
52152
52153
52154 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52155 PyObject *resultobj = 0;
52156 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52157 int result;
52158 void *argp1 = 0 ;
52159 int res1 = 0 ;
52160 PyObject *swig_obj[1] ;
52161
52162 if (!args) SWIG_fail;
52163 swig_obj[0] = args;
52164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52165 if (!SWIG_IsOK(res1)) {
52166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52167 }
52168 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52169 {
52170 PyThreadState* __tstate = wxPyBeginAllowThreads();
52171 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52172 wxPyEndAllowThreads(__tstate);
52173 if (PyErr_Occurred()) SWIG_fail;
52174 }
52175 resultobj = SWIG_From_int(static_cast< int >(result));
52176 return resultobj;
52177 fail:
52178 return NULL;
52179 }
52180
52181
52182 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52183 PyObject *resultobj = 0;
52184 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52185 int result;
52186 void *argp1 = 0 ;
52187 int res1 = 0 ;
52188 PyObject *swig_obj[1] ;
52189
52190 if (!args) SWIG_fail;
52191 swig_obj[0] = args;
52192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52193 if (!SWIG_IsOK(res1)) {
52194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52195 }
52196 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52197 {
52198 PyThreadState* __tstate = wxPyBeginAllowThreads();
52199 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52200 wxPyEndAllowThreads(__tstate);
52201 if (PyErr_Occurred()) SWIG_fail;
52202 }
52203 resultobj = SWIG_From_int(static_cast< int >(result));
52204 return resultobj;
52205 fail:
52206 return NULL;
52207 }
52208
52209
52210 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52211 PyObject *resultobj = 0;
52212 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52213 bool result;
52214 void *argp1 = 0 ;
52215 int res1 = 0 ;
52216 PyObject *swig_obj[1] ;
52217
52218 if (!args) SWIG_fail;
52219 swig_obj[0] = args;
52220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52221 if (!SWIG_IsOK(res1)) {
52222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52223 }
52224 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52225 {
52226 PyThreadState* __tstate = wxPyBeginAllowThreads();
52227 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52228 wxPyEndAllowThreads(__tstate);
52229 if (PyErr_Occurred()) SWIG_fail;
52230 }
52231 {
52232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52233 }
52234 return resultobj;
52235 fail:
52236 return NULL;
52237 }
52238
52239
52240 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52241 PyObject *resultobj = 0;
52242 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52243 bool arg2 ;
52244 void *argp1 = 0 ;
52245 int res1 = 0 ;
52246 bool val2 ;
52247 int ecode2 = 0 ;
52248 PyObject * obj0 = 0 ;
52249 PyObject * obj1 = 0 ;
52250 char * kwnames[] = {
52251 (char *) "self",(char *) "d", NULL
52252 };
52253
52254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52256 if (!SWIG_IsOK(res1)) {
52257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52258 }
52259 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52260 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52261 if (!SWIG_IsOK(ecode2)) {
52262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52263 }
52264 arg2 = static_cast< bool >(val2);
52265 {
52266 PyThreadState* __tstate = wxPyBeginAllowThreads();
52267 (arg1)->SetDone(arg2);
52268 wxPyEndAllowThreads(__tstate);
52269 if (PyErr_Occurred()) SWIG_fail;
52270 }
52271 resultobj = SWIG_Py_Void();
52272 return resultobj;
52273 fail:
52274 return NULL;
52275 }
52276
52277
52278 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52279 PyObject *resultobj = 0;
52280 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52281 wxRelationship result;
52282 void *argp1 = 0 ;
52283 int res1 = 0 ;
52284 PyObject *swig_obj[1] ;
52285
52286 if (!args) SWIG_fail;
52287 swig_obj[0] = args;
52288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52289 if (!SWIG_IsOK(res1)) {
52290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52291 }
52292 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52293 {
52294 PyThreadState* __tstate = wxPyBeginAllowThreads();
52295 result = (wxRelationship)(arg1)->GetRelationship();
52296 wxPyEndAllowThreads(__tstate);
52297 if (PyErr_Occurred()) SWIG_fail;
52298 }
52299 resultobj = SWIG_From_int(static_cast< int >(result));
52300 return resultobj;
52301 fail:
52302 return NULL;
52303 }
52304
52305
52306 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52307 PyObject *resultobj = 0;
52308 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52309 wxRelationship arg2 ;
52310 void *argp1 = 0 ;
52311 int res1 = 0 ;
52312 int val2 ;
52313 int ecode2 = 0 ;
52314 PyObject * obj0 = 0 ;
52315 PyObject * obj1 = 0 ;
52316 char * kwnames[] = {
52317 (char *) "self",(char *) "r", NULL
52318 };
52319
52320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52322 if (!SWIG_IsOK(res1)) {
52323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52324 }
52325 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52326 ecode2 = SWIG_AsVal_int(obj1, &val2);
52327 if (!SWIG_IsOK(ecode2)) {
52328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52329 }
52330 arg2 = static_cast< wxRelationship >(val2);
52331 {
52332 PyThreadState* __tstate = wxPyBeginAllowThreads();
52333 (arg1)->SetRelationship(arg2);
52334 wxPyEndAllowThreads(__tstate);
52335 if (PyErr_Occurred()) SWIG_fail;
52336 }
52337 resultobj = SWIG_Py_Void();
52338 return resultobj;
52339 fail:
52340 return NULL;
52341 }
52342
52343
52344 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52345 PyObject *resultobj = 0;
52346 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52347 wxWindow *arg2 = (wxWindow *) 0 ;
52348 bool result;
52349 void *argp1 = 0 ;
52350 int res1 = 0 ;
52351 void *argp2 = 0 ;
52352 int res2 = 0 ;
52353 PyObject * obj0 = 0 ;
52354 PyObject * obj1 = 0 ;
52355 char * kwnames[] = {
52356 (char *) "self",(char *) "otherW", NULL
52357 };
52358
52359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52361 if (!SWIG_IsOK(res1)) {
52362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52363 }
52364 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52365 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52366 if (!SWIG_IsOK(res2)) {
52367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52368 }
52369 arg2 = reinterpret_cast< wxWindow * >(argp2);
52370 {
52371 PyThreadState* __tstate = wxPyBeginAllowThreads();
52372 result = (bool)(arg1)->ResetIfWin(arg2);
52373 wxPyEndAllowThreads(__tstate);
52374 if (PyErr_Occurred()) SWIG_fail;
52375 }
52376 {
52377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52378 }
52379 return resultobj;
52380 fail:
52381 return NULL;
52382 }
52383
52384
52385 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52386 PyObject *resultobj = 0;
52387 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52388 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52389 wxWindow *arg3 = (wxWindow *) 0 ;
52390 bool result;
52391 void *argp1 = 0 ;
52392 int res1 = 0 ;
52393 void *argp2 = 0 ;
52394 int res2 = 0 ;
52395 void *argp3 = 0 ;
52396 int res3 = 0 ;
52397 PyObject * obj0 = 0 ;
52398 PyObject * obj1 = 0 ;
52399 PyObject * obj2 = 0 ;
52400 char * kwnames[] = {
52401 (char *) "self",(char *) "constraints",(char *) "win", NULL
52402 };
52403
52404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52406 if (!SWIG_IsOK(res1)) {
52407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52408 }
52409 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52410 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52411 if (!SWIG_IsOK(res2)) {
52412 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52413 }
52414 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52415 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52416 if (!SWIG_IsOK(res3)) {
52417 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52418 }
52419 arg3 = reinterpret_cast< wxWindow * >(argp3);
52420 {
52421 PyThreadState* __tstate = wxPyBeginAllowThreads();
52422 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52423 wxPyEndAllowThreads(__tstate);
52424 if (PyErr_Occurred()) SWIG_fail;
52425 }
52426 {
52427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52428 }
52429 return resultobj;
52430 fail:
52431 return NULL;
52432 }
52433
52434
52435 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52436 PyObject *resultobj = 0;
52437 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52438 wxEdge arg2 ;
52439 wxWindow *arg3 = (wxWindow *) 0 ;
52440 wxWindow *arg4 = (wxWindow *) 0 ;
52441 int result;
52442 void *argp1 = 0 ;
52443 int res1 = 0 ;
52444 int val2 ;
52445 int ecode2 = 0 ;
52446 void *argp3 = 0 ;
52447 int res3 = 0 ;
52448 void *argp4 = 0 ;
52449 int res4 = 0 ;
52450 PyObject * obj0 = 0 ;
52451 PyObject * obj1 = 0 ;
52452 PyObject * obj2 = 0 ;
52453 PyObject * obj3 = 0 ;
52454 char * kwnames[] = {
52455 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52456 };
52457
52458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52460 if (!SWIG_IsOK(res1)) {
52461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52462 }
52463 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52464 ecode2 = SWIG_AsVal_int(obj1, &val2);
52465 if (!SWIG_IsOK(ecode2)) {
52466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52467 }
52468 arg2 = static_cast< wxEdge >(val2);
52469 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52470 if (!SWIG_IsOK(res3)) {
52471 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52472 }
52473 arg3 = reinterpret_cast< wxWindow * >(argp3);
52474 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52475 if (!SWIG_IsOK(res4)) {
52476 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52477 }
52478 arg4 = reinterpret_cast< wxWindow * >(argp4);
52479 {
52480 PyThreadState* __tstate = wxPyBeginAllowThreads();
52481 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52482 wxPyEndAllowThreads(__tstate);
52483 if (PyErr_Occurred()) SWIG_fail;
52484 }
52485 resultobj = SWIG_From_int(static_cast< int >(result));
52486 return resultobj;
52487 fail:
52488 return NULL;
52489 }
52490
52491
52492 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52493 PyObject *obj;
52494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52495 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52496 return SWIG_Py_Void();
52497 }
52498
52499 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52500 PyObject *resultobj = 0;
52501 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52502 wxIndividualLayoutConstraint *result = 0 ;
52503 void *argp1 = 0 ;
52504 int res1 = 0 ;
52505 PyObject *swig_obj[1] ;
52506
52507 if (!args) SWIG_fail;
52508 swig_obj[0] = args;
52509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52510 if (!SWIG_IsOK(res1)) {
52511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52512 }
52513 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52514 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52516 return resultobj;
52517 fail:
52518 return NULL;
52519 }
52520
52521
52522 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52523 PyObject *resultobj = 0;
52524 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52525 wxIndividualLayoutConstraint *result = 0 ;
52526 void *argp1 = 0 ;
52527 int res1 = 0 ;
52528 PyObject *swig_obj[1] ;
52529
52530 if (!args) SWIG_fail;
52531 swig_obj[0] = args;
52532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52533 if (!SWIG_IsOK(res1)) {
52534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52535 }
52536 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52537 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52539 return resultobj;
52540 fail:
52541 return NULL;
52542 }
52543
52544
52545 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52546 PyObject *resultobj = 0;
52547 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52548 wxIndividualLayoutConstraint *result = 0 ;
52549 void *argp1 = 0 ;
52550 int res1 = 0 ;
52551 PyObject *swig_obj[1] ;
52552
52553 if (!args) SWIG_fail;
52554 swig_obj[0] = args;
52555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52556 if (!SWIG_IsOK(res1)) {
52557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52558 }
52559 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52560 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52562 return resultobj;
52563 fail:
52564 return NULL;
52565 }
52566
52567
52568 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52569 PyObject *resultobj = 0;
52570 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52571 wxIndividualLayoutConstraint *result = 0 ;
52572 void *argp1 = 0 ;
52573 int res1 = 0 ;
52574 PyObject *swig_obj[1] ;
52575
52576 if (!args) SWIG_fail;
52577 swig_obj[0] = args;
52578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52579 if (!SWIG_IsOK(res1)) {
52580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52581 }
52582 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52583 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52585 return resultobj;
52586 fail:
52587 return NULL;
52588 }
52589
52590
52591 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52592 PyObject *resultobj = 0;
52593 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52594 wxIndividualLayoutConstraint *result = 0 ;
52595 void *argp1 = 0 ;
52596 int res1 = 0 ;
52597 PyObject *swig_obj[1] ;
52598
52599 if (!args) SWIG_fail;
52600 swig_obj[0] = args;
52601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52602 if (!SWIG_IsOK(res1)) {
52603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52604 }
52605 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52606 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52608 return resultobj;
52609 fail:
52610 return NULL;
52611 }
52612
52613
52614 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52615 PyObject *resultobj = 0;
52616 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52617 wxIndividualLayoutConstraint *result = 0 ;
52618 void *argp1 = 0 ;
52619 int res1 = 0 ;
52620 PyObject *swig_obj[1] ;
52621
52622 if (!args) SWIG_fail;
52623 swig_obj[0] = args;
52624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52625 if (!SWIG_IsOK(res1)) {
52626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52627 }
52628 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52629 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52631 return resultobj;
52632 fail:
52633 return NULL;
52634 }
52635
52636
52637 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52638 PyObject *resultobj = 0;
52639 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52640 wxIndividualLayoutConstraint *result = 0 ;
52641 void *argp1 = 0 ;
52642 int res1 = 0 ;
52643 PyObject *swig_obj[1] ;
52644
52645 if (!args) SWIG_fail;
52646 swig_obj[0] = args;
52647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52648 if (!SWIG_IsOK(res1)) {
52649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52650 }
52651 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52652 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52654 return resultobj;
52655 fail:
52656 return NULL;
52657 }
52658
52659
52660 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52661 PyObject *resultobj = 0;
52662 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52663 wxIndividualLayoutConstraint *result = 0 ;
52664 void *argp1 = 0 ;
52665 int res1 = 0 ;
52666 PyObject *swig_obj[1] ;
52667
52668 if (!args) SWIG_fail;
52669 swig_obj[0] = args;
52670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52671 if (!SWIG_IsOK(res1)) {
52672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52673 }
52674 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52675 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52677 return resultobj;
52678 fail:
52679 return NULL;
52680 }
52681
52682
52683 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52684 PyObject *resultobj = 0;
52685 wxLayoutConstraints *result = 0 ;
52686
52687 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52688 {
52689 PyThreadState* __tstate = wxPyBeginAllowThreads();
52690 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52691 wxPyEndAllowThreads(__tstate);
52692 if (PyErr_Occurred()) SWIG_fail;
52693 }
52694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52695 return resultobj;
52696 fail:
52697 return NULL;
52698 }
52699
52700
52701 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52702 PyObject *resultobj = 0;
52703 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52704 void *argp1 = 0 ;
52705 int res1 = 0 ;
52706 PyObject *swig_obj[1] ;
52707
52708 if (!args) SWIG_fail;
52709 swig_obj[0] = args;
52710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52711 if (!SWIG_IsOK(res1)) {
52712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52713 }
52714 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52715 {
52716 PyThreadState* __tstate = wxPyBeginAllowThreads();
52717 delete arg1;
52718
52719 wxPyEndAllowThreads(__tstate);
52720 if (PyErr_Occurred()) SWIG_fail;
52721 }
52722 resultobj = SWIG_Py_Void();
52723 return resultobj;
52724 fail:
52725 return NULL;
52726 }
52727
52728
52729 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52730 PyObject *resultobj = 0;
52731 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52732 wxWindow *arg2 = (wxWindow *) 0 ;
52733 int *arg3 = (int *) 0 ;
52734 bool result;
52735 void *argp1 = 0 ;
52736 int res1 = 0 ;
52737 void *argp2 = 0 ;
52738 int res2 = 0 ;
52739 int temp3 ;
52740 int res3 = SWIG_TMPOBJ ;
52741 PyObject * obj0 = 0 ;
52742 PyObject * obj1 = 0 ;
52743 char * kwnames[] = {
52744 (char *) "self",(char *) "win", NULL
52745 };
52746
52747 arg3 = &temp3;
52748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52750 if (!SWIG_IsOK(res1)) {
52751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52752 }
52753 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52754 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52755 if (!SWIG_IsOK(res2)) {
52756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52757 }
52758 arg2 = reinterpret_cast< wxWindow * >(argp2);
52759 {
52760 PyThreadState* __tstate = wxPyBeginAllowThreads();
52761 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52762 wxPyEndAllowThreads(__tstate);
52763 if (PyErr_Occurred()) SWIG_fail;
52764 }
52765 {
52766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52767 }
52768 if (SWIG_IsTmpObj(res3)) {
52769 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52770 } else {
52771 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52772 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52773 }
52774 return resultobj;
52775 fail:
52776 return NULL;
52777 }
52778
52779
52780 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52781 PyObject *resultobj = 0;
52782 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52783 bool result;
52784 void *argp1 = 0 ;
52785 int res1 = 0 ;
52786 PyObject *swig_obj[1] ;
52787
52788 if (!args) SWIG_fail;
52789 swig_obj[0] = args;
52790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52791 if (!SWIG_IsOK(res1)) {
52792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52793 }
52794 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52795 {
52796 PyThreadState* __tstate = wxPyBeginAllowThreads();
52797 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52798 wxPyEndAllowThreads(__tstate);
52799 if (PyErr_Occurred()) SWIG_fail;
52800 }
52801 {
52802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52803 }
52804 return resultobj;
52805 fail:
52806 return NULL;
52807 }
52808
52809
52810 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52811 PyObject *obj;
52812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52813 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52814 return SWIG_Py_Void();
52815 }
52816
52817 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52818 return SWIG_Python_InitShadowInstance(args);
52819 }
52820
52821 static PyMethodDef SwigMethods[] = {
52822 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52823 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52824 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52825 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52826 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52827 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52828 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52829 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52830 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52831 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52832 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52834 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52835 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52839 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52843 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52844 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52845 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52847 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52848 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52849 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52850 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52851 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52852 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52853 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52855 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52858 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52861 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52862 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52863 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52864 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52865 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52866 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52867 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52868 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52869 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52870 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52877 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52878 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52879 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52884 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52885 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52887 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52889 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52890 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52891 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52892 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52893 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52894 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52895 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52896 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52897 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52898 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52900 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52902 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52903 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52904 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52905 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52910 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52916 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52917 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52919 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52921 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52923 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52924 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52925 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52926 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52927 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52928 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52929 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52930 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52931 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52933 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52934 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52935 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52940 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52941 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52942 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52943 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52946 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52947 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52950 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52954 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52956 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52957 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52958 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52959 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52960 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52962 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52963 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52964 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52966 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52967 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52968 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52969 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52970 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52972 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52973 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52974 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52975 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52976 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52977 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52978 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52979 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52980 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52982 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52983 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52984 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52986 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52987 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52988 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52989 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52990 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52991 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52992 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52993 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52994 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52995 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52996 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52997 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52998 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52999 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53000 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53003 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53004 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53005 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53008 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53009 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53010 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53011 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53012 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53013 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53015 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53016 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53018 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53019 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53020 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53023 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53024 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53025 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53028 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53029 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53030 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53034 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53035 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53036 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53037 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53038 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53039 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53040 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53041 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53045 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53046 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53047 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53048 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53049 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53050 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53051 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53054 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53058 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53059 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53061 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53062 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53063 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53067 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53069 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53070 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53072 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53073 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53074 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53075 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53076 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53077 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53078 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53079 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53080 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53081 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53082 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53083 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53084 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53085 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53086 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53087 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53088 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53090 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53091 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53099 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53107 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53111 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53112 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53127 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53128 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53129 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53130 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53133 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53135 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53137 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53139 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53141 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53144 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53145 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53146 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53147 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53149 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53166 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53167 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53169 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53171 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53173 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53174 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53175 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53176 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53177 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53178 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53179 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53180 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53181 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53182 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53183 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53184 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53185 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53186 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53187 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53188 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53189 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53190 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53191 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53192 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53193 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53194 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53195 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53196 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53197 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53198 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53199 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53200 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53201 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53202 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53203 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53204 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53205 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53206 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53207 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53209 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53210 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53211 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53212 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53215 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53216 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53219 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53221 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53223 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53224 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53225 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53226 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53227 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53228 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53229 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53231 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53233 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53235 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53237 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53238 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53239 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53241 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53242 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53244 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53245 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53246 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53248 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53249 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53250 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53252 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53254 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53255 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53256 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53258 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53260 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53261 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53263 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53264 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53265 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53267 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53268 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53269 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53270 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53271 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53273 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53274 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53277 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53278 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53280 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53281 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53284 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53285 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53287 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53293 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53294 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53295 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53296 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53297 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53298 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53299 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53300 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53301 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53302 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53303 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53304 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53305 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53306 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53307 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53308 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53309 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53310 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53311 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53312 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53313 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53314 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53315 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53316 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53317 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53318 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53319 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53320 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53321 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53322 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53323 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53324 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53325 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53326 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53327 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53328 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53329 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53330 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53331 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53332 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53333 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53334 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53335 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53336 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53337 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53338 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53339 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53340 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53341 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53342 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53343 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53344 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53345 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53346 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53347 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53348 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53349 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53351 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53352 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53354 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53355 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53356 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53357 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53359 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53360 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53361 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53362 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53363 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53364 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53365 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53366 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53367 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53369 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53370 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53371 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53372 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53373 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53374 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53375 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53376 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53377 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53378 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53379 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53380 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53381 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53382 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53383 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53384 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53385 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53386 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53387 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53388 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53389 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53390 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53391 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53392 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53393 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53394 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53395 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53396 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53398 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53399 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53402 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53403 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53404 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53405 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53406 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53407 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53409 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53410 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53413 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53414 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53416 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53417 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53419 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53420 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53422 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53423 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53424 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53426 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53428 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53429 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53431 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53432 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53433 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53435 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53436 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53437 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53439 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53440 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53442 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53443 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53444 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53445 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53446 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53449 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53451 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53453 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53454 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53455 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53458 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53459 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53460 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53462 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53463 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53464 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53466 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53467 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53468 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53469 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53470 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53471 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53473 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53474 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53475 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53476 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53477 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53478 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53479 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53480 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53486 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53488 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53490 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53491 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53492 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53493 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53494 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53495 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53497 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53498 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53499 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53500 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53501 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53502 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53505 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53506 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53507 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53510 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53511 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53512 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53513 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53514 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53516 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53518 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53521 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53523 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53524 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53526 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53527 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53528 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53530 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53531 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53532 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53534 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53536 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53537 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53538 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53540 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53542 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53544 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53545 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53547 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53548 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53550 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53552 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53553 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53554 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53556 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53558 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53559 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53560 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53562 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53564 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53565 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53566 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53567 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53569 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53571 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53573 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53575 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53576 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53578 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53579 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53580 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53581 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53582 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53583 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53584 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53585 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53587 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53589 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53591 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53592 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53593 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53595 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53597 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53598 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53599 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53600 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53601 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53602 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53608 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53609 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53610 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53611 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53612 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53613 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53614 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53616 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53618 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53619 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53621 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53622 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53623 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53624 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53626 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53627 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53628 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53629 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53631 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53632 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53634 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53635 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53636 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53638 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53640 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53641 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53642 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53643 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53644 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53646 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53647 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53648 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53649 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53651 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53652 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53653 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53654 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53655 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53656 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53657 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53658 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53659 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53660 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53662 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53665 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53666 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53667 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53669 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53671 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53673 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53675 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53676 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53686 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53687 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53691 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53692 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53693 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53694 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53695 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53696 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53697 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53698 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53699 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53700 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53701 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53702 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53703 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53704 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53705 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53707 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53708 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53711 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53712 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53717 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53718 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53721 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53722 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53723 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53724 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53727 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53728 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53729 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53731 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53733 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53734 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53735 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53737 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53739 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53741 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53744 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53745 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53746 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53747 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53748 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53749 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53753 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53754 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53755 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53756 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53763 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53769 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53770 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53771 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53772 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53773 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53775 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53785 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53786 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53787 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53788 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53791 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53792 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53793 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53794 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53796 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53797 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53801 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53807 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53808 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53809 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53810 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53812 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53813 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53815 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53818 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53820 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53821 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53822 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53831 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
53835 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53836 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53838 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53848 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53849 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53850 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53851 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53855 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53858 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53860 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53863 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53865 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53866 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53869 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53871 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53872 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53873 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53874 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53875 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53880 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53881 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53882 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53884 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53885 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53886 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53888 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53890 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53891 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53892 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53894 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53895 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53898 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53906 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53913 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53921 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53924 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53925 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53938 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53940 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53942 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53943 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53945 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53947 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53948 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53950 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53951 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53952 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53956 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53975 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53976 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53978 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53980 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53981 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53982 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53984 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53985 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53988 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53989 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53991 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53992 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53994 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53997 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53998 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54000 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54002 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54004 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54005 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54007 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54008 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54011 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54013 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54015 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54017 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54020 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54021 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54022 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54023 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54024 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54026 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54027 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54028 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54030 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54032 { (char *)"Control_GetLabelText", _wrap_Control_GetLabelText, METH_VARARGS, NULL},
54033 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54035 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54037 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54038 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54042 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54046 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54047 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54049 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54053 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54055 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54057 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54058 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54059 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54060 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54064 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54065 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54066 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54067 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54069 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54070 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54075 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54076 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54077 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54078 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54079 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54081 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54083 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54085 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54086 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54088 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54090 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54093 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54094 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54095 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54097 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54098 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54099 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54107 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54108 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54113 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54114 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54115 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54116 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54117 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54118 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54120 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54124 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54125 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54126 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54129 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54130 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54132 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54133 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54135 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54137 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54138 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54140 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54141 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54142 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54148 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54149 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54150 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54151 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54152 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54153 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54160 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54162 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54163 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54164 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54165 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54166 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54167 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54169 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54173 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54174 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54175 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54176 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54177 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54178 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54179 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54181 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54182 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54183 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54184 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54187 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54189 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54190 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54191 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54192 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54193 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54194 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54195 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54201 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54202 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54203 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54204 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54205 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54209 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54210 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54211 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54212 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54213 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54215 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54216 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54218 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54219 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54220 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54224 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54225 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54226 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54227 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54228 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54229 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54230 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54231 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54234 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54235 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54236 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54237 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54238 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54239 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54240 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54241 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54242 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54243 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54244 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54245 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54246 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54247 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54248 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54249 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54250 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54251 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54252 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54253 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54254 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54255 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54256 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54257 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54258 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54259 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54260 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54261 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54262 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54263 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54264 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54265 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54266 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54267 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54268 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54269 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54270 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54271 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54272 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54273 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54274 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54275 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54276 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54277 { NULL, NULL, 0, NULL }
54278 };
54279
54280
54281 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54282
54283 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54284 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54285 }
54286 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54287 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54288 }
54289 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54290 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54291 }
54292 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54293 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54294 }
54295 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54296 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54297 }
54298 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54299 return (void *)((wxSizer *) ((wxGridSizer *) x));
54300 }
54301 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54302 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54303 }
54304 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54305 return (void *)((wxSizer *) ((wxPySizer *) x));
54306 }
54307 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54308 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54309 }
54310 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54311 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54312 }
54313 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54314 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54315 }
54316 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54317 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54318 }
54319 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54320 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54321 }
54322 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54323 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54324 }
54325 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54326 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54327 }
54328 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54329 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54330 }
54331 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54332 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54333 }
54334 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54335 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54336 }
54337 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54338 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54339 }
54340 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54341 return (void *)((wxEvent *) ((wxPyEvent *) x));
54342 }
54343 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54344 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54345 }
54346 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54347 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54348 }
54349 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54350 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54351 }
54352 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54353 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54354 }
54355 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54356 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54357 }
54358 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54359 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54360 }
54361 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54362 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54363 }
54364 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54365 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54366 }
54367 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54368 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54369 }
54370 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54371 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54372 }
54373 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54374 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54375 }
54376 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54377 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54378 }
54379 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54380 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54381 }
54382 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54383 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54384 }
54385 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54386 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54387 }
54388 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54389 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54390 }
54391 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54392 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54393 }
54394 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54395 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54396 }
54397 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54398 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54399 }
54400 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54401 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54402 }
54403 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54404 return (void *)((wxEvent *) ((wxShowEvent *) x));
54405 }
54406 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54407 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54408 }
54409 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54410 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54411 }
54412 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54413 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54414 }
54415 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54416 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54417 }
54418 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54419 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54420 }
54421 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54422 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54423 }
54424 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54425 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54426 }
54427 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54428 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54429 }
54430 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54431 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54432 }
54433 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54434 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54435 }
54436 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54437 return (void *)((wxControl *) ((wxControlWithItems *) x));
54438 }
54439 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54440 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54441 }
54442 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54443 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54444 }
54445 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54446 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54447 }
54448 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54449 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54450 }
54451 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54452 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54453 }
54454 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54455 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54456 }
54457 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54458 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54459 }
54460 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54461 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54462 }
54463 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54464 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54465 }
54466 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54467 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54468 }
54469 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54470 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54471 }
54472 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54473 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54474 }
54475 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54476 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54477 }
54478 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54479 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54480 }
54481 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54482 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54483 }
54484 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54485 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54486 }
54487 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54488 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54489 }
54490 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54491 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54492 }
54493 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54494 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54495 }
54496 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54497 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54498 }
54499 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54500 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54501 }
54502 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54503 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54504 }
54505 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54506 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54507 }
54508 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54509 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54510 }
54511 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54512 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54513 }
54514 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54515 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54516 }
54517 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54518 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54519 }
54520 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54521 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54522 }
54523 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54524 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54525 }
54526 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54527 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54528 }
54529 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54530 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54531 }
54532 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54533 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54534 }
54535 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54536 return (void *)((wxObject *) ((wxSizerItem *) x));
54537 }
54538 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54539 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54540 }
54541 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54542 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54543 }
54544 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54545 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54546 }
54547 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54548 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54549 }
54550 static void *_p_wxSizerTo_p_wxObject(void *x) {
54551 return (void *)((wxObject *) ((wxSizer *) x));
54552 }
54553 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54554 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54555 }
54556 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54557 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54558 }
54559 static void *_p_wxEventTo_p_wxObject(void *x) {
54560 return (void *)((wxObject *) ((wxEvent *) x));
54561 }
54562 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54563 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54564 }
54565 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54566 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54567 }
54568 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54569 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54570 }
54571 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54572 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54573 }
54574 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54575 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54576 }
54577 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54578 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54579 }
54580 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54581 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54582 }
54583 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54584 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54585 }
54586 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54587 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54588 }
54589 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54590 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54591 }
54592 static void *_p_wxControlTo_p_wxObject(void *x) {
54593 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54594 }
54595 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54596 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54597 }
54598 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54599 return (void *)((wxObject *) ((wxFSFile *) x));
54600 }
54601 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54602 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54603 }
54604 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54605 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54606 }
54607 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54608 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54609 }
54610 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54611 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54612 }
54613 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54614 return (void *)((wxObject *) ((wxMenuItem *) x));
54615 }
54616 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54617 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54618 }
54619 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54620 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54621 }
54622 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54623 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54624 }
54625 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54626 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54627 }
54628 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54629 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54630 }
54631 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54632 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54633 }
54634 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54635 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54636 }
54637 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54638 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54639 }
54640 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54641 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54642 }
54643 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54644 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54645 }
54646 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54647 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54648 }
54649 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54650 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54651 }
54652 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54653 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54654 }
54655 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54656 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54657 }
54658 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54659 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54660 }
54661 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54662 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54663 }
54664 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54665 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54666 }
54667 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54668 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54669 }
54670 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54671 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54672 }
54673 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54674 return (void *)((wxObject *) ((wxImageHandler *) x));
54675 }
54676 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54677 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54678 }
54679 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54680 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54681 }
54682 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54683 return (void *)((wxObject *) ((wxEvtHandler *) x));
54684 }
54685 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54686 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54687 }
54688 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54689 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54690 }
54691 static void *_p_wxImageTo_p_wxObject(void *x) {
54692 return (void *)((wxObject *) ((wxImage *) x));
54693 }
54694 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54695 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54696 }
54697 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54698 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54699 }
54700 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54701 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54702 }
54703 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54704 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54705 }
54706 static void *_p_wxWindowTo_p_wxObject(void *x) {
54707 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54708 }
54709 static void *_p_wxMenuTo_p_wxObject(void *x) {
54710 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54711 }
54712 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54713 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54714 }
54715 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54716 return (void *)((wxObject *) ((wxFileSystem *) x));
54717 }
54718 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54719 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54720 }
54721 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54722 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54723 }
54724 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54725 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54726 }
54727 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54728 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54729 }
54730 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54731 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54732 }
54733 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54734 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54735 }
54736 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54737 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54738 }
54739 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54740 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54741 }
54742 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54743 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54744 }
54745 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54746 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54747 }
54748 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54749 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54750 }
54751 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54752 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54753 }
54754 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54755 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54756 }
54757 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54758 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54759 }
54760 static void *_p_wxControlTo_p_wxWindow(void *x) {
54761 return (void *)((wxWindow *) ((wxControl *) x));
54762 }
54763 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54764 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54765 }
54766 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54767 return (void *)((wxWindow *) ((wxMenuBar *) x));
54768 }
54769 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54770 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54771 }
54772 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54773 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54774 }
54775 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54776 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54777 }
54778 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54779 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54780 }
54781 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54782 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54783 }
54784 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54785 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54786 }
54787 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54788 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54789 }
54790 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54791 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54792 }
54793 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54794 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54795 }
54796 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54797 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54798 }
54799 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54800 return (void *)((wxValidator *) ((wxPyValidator *) x));
54801 }
54802 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54803 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54804 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};
54805 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54806 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54807 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54808 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54809 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54810 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54811 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54812 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54813 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54814 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54815 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54816 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54817 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54818 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54819 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54820 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54821 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54822 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54823 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54824 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54825 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54826 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54827 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54828 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54829 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54831 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54832 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54833 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54834 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54835 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54836 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54837 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54838 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54839 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54840 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54841 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54842 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54843 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54844 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54845 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54846 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54847 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54848 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54849 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54850 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54851 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54852 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54853 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54854 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54855 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54856 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54857 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54858 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54859 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54860 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54861 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54862 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54863 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54864 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54865 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54866 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54867 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54868 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54869 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54870 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54871 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54872 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54873 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54874 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54875 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54876 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54877 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54878 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54879 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54880 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54881 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54882 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54883 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54884 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54885 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54886 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54887 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54888 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54889 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54890 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54891 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54892 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54893 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54894 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54895 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54896 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54897 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54898 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54899 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54900 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54901 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54902 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54903 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54904 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54905 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54906 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54907 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54908 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54909 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54910 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54911 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54912 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54913 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54914 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54915 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54916 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54917 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54918 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54919 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54920 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54921 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54922 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54923 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54924 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54925 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54926 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54927 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54928 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54929 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54930 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54931 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54932 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54933
54934 static swig_type_info *swig_type_initial[] = {
54935 &_swigt__p_buffer,
54936 &_swigt__p_char,
54937 &_swigt__p_form_ops_t,
54938 &_swigt__p_int,
54939 &_swigt__p_long,
54940 &_swigt__p_unsigned_char,
54941 &_swigt__p_unsigned_int,
54942 &_swigt__p_unsigned_long,
54943 &_swigt__p_wxANIHandler,
54944 &_swigt__p_wxAcceleratorEntry,
54945 &_swigt__p_wxAcceleratorTable,
54946 &_swigt__p_wxActivateEvent,
54947 &_swigt__p_wxAppTraits,
54948 &_swigt__p_wxArrayString,
54949 &_swigt__p_wxBMPHandler,
54950 &_swigt__p_wxBitmap,
54951 &_swigt__p_wxBoxSizer,
54952 &_swigt__p_wxButton,
54953 &_swigt__p_wxCURHandler,
54954 &_swigt__p_wxCaret,
54955 &_swigt__p_wxChildFocusEvent,
54956 &_swigt__p_wxClipboardTextEvent,
54957 &_swigt__p_wxCloseEvent,
54958 &_swigt__p_wxColour,
54959 &_swigt__p_wxCommandEvent,
54960 &_swigt__p_wxContextMenuEvent,
54961 &_swigt__p_wxControl,
54962 &_swigt__p_wxControlWithItems,
54963 &_swigt__p_wxCursor,
54964 &_swigt__p_wxDC,
54965 &_swigt__p_wxDateEvent,
54966 &_swigt__p_wxDateTime,
54967 &_swigt__p_wxDisplayChangedEvent,
54968 &_swigt__p_wxDropFilesEvent,
54969 &_swigt__p_wxDuplexMode,
54970 &_swigt__p_wxEraseEvent,
54971 &_swigt__p_wxEvent,
54972 &_swigt__p_wxEventLoop,
54973 &_swigt__p_wxEventLoopActivator,
54974 &_swigt__p_wxEvtHandler,
54975 &_swigt__p_wxFSFile,
54976 &_swigt__p_wxFileSystem,
54977 &_swigt__p_wxFileSystemHandler,
54978 &_swigt__p_wxFlexGridSizer,
54979 &_swigt__p_wxFocusEvent,
54980 &_swigt__p_wxFont,
54981 &_swigt__p_wxFrame,
54982 &_swigt__p_wxGBPosition,
54983 &_swigt__p_wxGBSizerItem,
54984 &_swigt__p_wxGBSpan,
54985 &_swigt__p_wxGIFHandler,
54986 &_swigt__p_wxGridBagSizer,
54987 &_swigt__p_wxGridSizer,
54988 &_swigt__p_wxHelpEvent__Origin,
54989 &_swigt__p_wxICOHandler,
54990 &_swigt__p_wxIconizeEvent,
54991 &_swigt__p_wxIdleEvent,
54992 &_swigt__p_wxImage,
54993 &_swigt__p_wxImageHandler,
54994 &_swigt__p_wxImageHistogram,
54995 &_swigt__p_wxImage_HSVValue,
54996 &_swigt__p_wxImage_RGBValue,
54997 &_swigt__p_wxIndividualLayoutConstraint,
54998 &_swigt__p_wxInitDialogEvent,
54999 &_swigt__p_wxInputStream,
55000 &_swigt__p_wxInternetFSHandler,
55001 &_swigt__p_wxItemContainer,
55002 &_swigt__p_wxJPEGHandler,
55003 &_swigt__p_wxKeyEvent,
55004 &_swigt__p_wxLayoutConstraints,
55005 &_swigt__p_wxMaximizeEvent,
55006 &_swigt__p_wxMemoryFSHandler,
55007 &_swigt__p_wxMenu,
55008 &_swigt__p_wxMenuBar,
55009 &_swigt__p_wxMenuBarBase,
55010 &_swigt__p_wxMenuEvent,
55011 &_swigt__p_wxMenuItem,
55012 &_swigt__p_wxMouseCaptureChangedEvent,
55013 &_swigt__p_wxMouseEvent,
55014 &_swigt__p_wxMoveEvent,
55015 &_swigt__p_wxNavigationKeyEvent,
55016 &_swigt__p_wxNcPaintEvent,
55017 &_swigt__p_wxNotifyEvent,
55018 &_swigt__p_wxObject,
55019 &_swigt__p_wxOutputStream,
55020 &_swigt__p_wxPCXHandler,
55021 &_swigt__p_wxPNGHandler,
55022 &_swigt__p_wxPNMHandler,
55023 &_swigt__p_wxPaintEvent,
55024 &_swigt__p_wxPaletteChangedEvent,
55025 &_swigt__p_wxPaperSize,
55026 &_swigt__p_wxPoint,
55027 &_swigt__p_wxPoint2D,
55028 &_swigt__p_wxPropagateOnce,
55029 &_swigt__p_wxPropagationDisabler,
55030 &_swigt__p_wxPyApp,
55031 &_swigt__p_wxPyCommandEvent,
55032 &_swigt__p_wxPyDropTarget,
55033 &_swigt__p_wxPyEvent,
55034 &_swigt__p_wxPyFileSystemHandler,
55035 &_swigt__p_wxPyImageHandler,
55036 &_swigt__p_wxPyInputStream,
55037 &_swigt__p_wxPySizer,
55038 &_swigt__p_wxPyValidator,
55039 &_swigt__p_wxQuantize,
55040 &_swigt__p_wxQueryNewPaletteEvent,
55041 &_swigt__p_wxRealPoint,
55042 &_swigt__p_wxRect,
55043 &_swigt__p_wxRegion,
55044 &_swigt__p_wxScrollEvent,
55045 &_swigt__p_wxScrollWinEvent,
55046 &_swigt__p_wxSetCursorEvent,
55047 &_swigt__p_wxShowEvent,
55048 &_swigt__p_wxSize,
55049 &_swigt__p_wxSizeEvent,
55050 &_swigt__p_wxSizer,
55051 &_swigt__p_wxSizerItem,
55052 &_swigt__p_wxStaticBox,
55053 &_swigt__p_wxStaticBoxSizer,
55054 &_swigt__p_wxStdDialogButtonSizer,
55055 &_swigt__p_wxSysColourChangedEvent,
55056 &_swigt__p_wxTIFFHandler,
55057 &_swigt__p_wxToolTip,
55058 &_swigt__p_wxUpdateUIEvent,
55059 &_swigt__p_wxValidator,
55060 &_swigt__p_wxVisualAttributes,
55061 &_swigt__p_wxWindow,
55062 &_swigt__p_wxWindowCreateEvent,
55063 &_swigt__p_wxWindowDestroyEvent,
55064 &_swigt__p_wxXPMHandler,
55065 &_swigt__p_wxZipFSHandler,
55066 };
55067
55068 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55069 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55070 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55071 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55072 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55073 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55074 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55075 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55076 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55077 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55078 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55079 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55080 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55081 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55082 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}};
55083 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55084 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}};
55085 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55086 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}};
55087 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55088 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55089 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55090 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55091 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55092 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}};
55093 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55094 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}};
55095 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55096 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55097 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55098 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55099 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55100 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55101 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55102 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55103 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55104 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
55105 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55106 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55107 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}};
55108 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55109 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55110 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}};
55111 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}};
55112 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55113 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55114 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55115 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55116 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55117 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55118 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55119 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55120 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}};
55121 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55122 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}};
55123 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55124 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55125 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55126 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}};
55127 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55128 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55129 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55130 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55131 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55132 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55133 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55134 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}};
55135 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55136 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55137 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55138 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55139 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55140 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55141 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55142 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55143 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55144 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55145 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55146 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55147 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55148 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55149 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55150 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55151 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
55152 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55153 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55154 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55155 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55156 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55157 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55158 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55159 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55160 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55161 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55162 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55163 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55164 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55165 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55166 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55167 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55168 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55169 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55170 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55171 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55172 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55173 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55174 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55175 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55176 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55177 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55178 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55179 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55180 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55181 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55182 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55183 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}};
55184 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}};
55185 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55186 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55187 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55188 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55189 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55190 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55191 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55192 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}};
55193 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55194 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}};
55195 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55196 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55197 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55198 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55199
55200 static swig_cast_info *swig_cast_initial[] = {
55201 _swigc__p_buffer,
55202 _swigc__p_char,
55203 _swigc__p_form_ops_t,
55204 _swigc__p_int,
55205 _swigc__p_long,
55206 _swigc__p_unsigned_char,
55207 _swigc__p_unsigned_int,
55208 _swigc__p_unsigned_long,
55209 _swigc__p_wxANIHandler,
55210 _swigc__p_wxAcceleratorEntry,
55211 _swigc__p_wxAcceleratorTable,
55212 _swigc__p_wxActivateEvent,
55213 _swigc__p_wxAppTraits,
55214 _swigc__p_wxArrayString,
55215 _swigc__p_wxBMPHandler,
55216 _swigc__p_wxBitmap,
55217 _swigc__p_wxBoxSizer,
55218 _swigc__p_wxButton,
55219 _swigc__p_wxCURHandler,
55220 _swigc__p_wxCaret,
55221 _swigc__p_wxChildFocusEvent,
55222 _swigc__p_wxClipboardTextEvent,
55223 _swigc__p_wxCloseEvent,
55224 _swigc__p_wxColour,
55225 _swigc__p_wxCommandEvent,
55226 _swigc__p_wxContextMenuEvent,
55227 _swigc__p_wxControl,
55228 _swigc__p_wxControlWithItems,
55229 _swigc__p_wxCursor,
55230 _swigc__p_wxDC,
55231 _swigc__p_wxDateEvent,
55232 _swigc__p_wxDateTime,
55233 _swigc__p_wxDisplayChangedEvent,
55234 _swigc__p_wxDropFilesEvent,
55235 _swigc__p_wxDuplexMode,
55236 _swigc__p_wxEraseEvent,
55237 _swigc__p_wxEvent,
55238 _swigc__p_wxEventLoop,
55239 _swigc__p_wxEventLoopActivator,
55240 _swigc__p_wxEvtHandler,
55241 _swigc__p_wxFSFile,
55242 _swigc__p_wxFileSystem,
55243 _swigc__p_wxFileSystemHandler,
55244 _swigc__p_wxFlexGridSizer,
55245 _swigc__p_wxFocusEvent,
55246 _swigc__p_wxFont,
55247 _swigc__p_wxFrame,
55248 _swigc__p_wxGBPosition,
55249 _swigc__p_wxGBSizerItem,
55250 _swigc__p_wxGBSpan,
55251 _swigc__p_wxGIFHandler,
55252 _swigc__p_wxGridBagSizer,
55253 _swigc__p_wxGridSizer,
55254 _swigc__p_wxHelpEvent__Origin,
55255 _swigc__p_wxICOHandler,
55256 _swigc__p_wxIconizeEvent,
55257 _swigc__p_wxIdleEvent,
55258 _swigc__p_wxImage,
55259 _swigc__p_wxImageHandler,
55260 _swigc__p_wxImageHistogram,
55261 _swigc__p_wxImage_HSVValue,
55262 _swigc__p_wxImage_RGBValue,
55263 _swigc__p_wxIndividualLayoutConstraint,
55264 _swigc__p_wxInitDialogEvent,
55265 _swigc__p_wxInputStream,
55266 _swigc__p_wxInternetFSHandler,
55267 _swigc__p_wxItemContainer,
55268 _swigc__p_wxJPEGHandler,
55269 _swigc__p_wxKeyEvent,
55270 _swigc__p_wxLayoutConstraints,
55271 _swigc__p_wxMaximizeEvent,
55272 _swigc__p_wxMemoryFSHandler,
55273 _swigc__p_wxMenu,
55274 _swigc__p_wxMenuBar,
55275 _swigc__p_wxMenuBarBase,
55276 _swigc__p_wxMenuEvent,
55277 _swigc__p_wxMenuItem,
55278 _swigc__p_wxMouseCaptureChangedEvent,
55279 _swigc__p_wxMouseEvent,
55280 _swigc__p_wxMoveEvent,
55281 _swigc__p_wxNavigationKeyEvent,
55282 _swigc__p_wxNcPaintEvent,
55283 _swigc__p_wxNotifyEvent,
55284 _swigc__p_wxObject,
55285 _swigc__p_wxOutputStream,
55286 _swigc__p_wxPCXHandler,
55287 _swigc__p_wxPNGHandler,
55288 _swigc__p_wxPNMHandler,
55289 _swigc__p_wxPaintEvent,
55290 _swigc__p_wxPaletteChangedEvent,
55291 _swigc__p_wxPaperSize,
55292 _swigc__p_wxPoint,
55293 _swigc__p_wxPoint2D,
55294 _swigc__p_wxPropagateOnce,
55295 _swigc__p_wxPropagationDisabler,
55296 _swigc__p_wxPyApp,
55297 _swigc__p_wxPyCommandEvent,
55298 _swigc__p_wxPyDropTarget,
55299 _swigc__p_wxPyEvent,
55300 _swigc__p_wxPyFileSystemHandler,
55301 _swigc__p_wxPyImageHandler,
55302 _swigc__p_wxPyInputStream,
55303 _swigc__p_wxPySizer,
55304 _swigc__p_wxPyValidator,
55305 _swigc__p_wxQuantize,
55306 _swigc__p_wxQueryNewPaletteEvent,
55307 _swigc__p_wxRealPoint,
55308 _swigc__p_wxRect,
55309 _swigc__p_wxRegion,
55310 _swigc__p_wxScrollEvent,
55311 _swigc__p_wxScrollWinEvent,
55312 _swigc__p_wxSetCursorEvent,
55313 _swigc__p_wxShowEvent,
55314 _swigc__p_wxSize,
55315 _swigc__p_wxSizeEvent,
55316 _swigc__p_wxSizer,
55317 _swigc__p_wxSizerItem,
55318 _swigc__p_wxStaticBox,
55319 _swigc__p_wxStaticBoxSizer,
55320 _swigc__p_wxStdDialogButtonSizer,
55321 _swigc__p_wxSysColourChangedEvent,
55322 _swigc__p_wxTIFFHandler,
55323 _swigc__p_wxToolTip,
55324 _swigc__p_wxUpdateUIEvent,
55325 _swigc__p_wxValidator,
55326 _swigc__p_wxVisualAttributes,
55327 _swigc__p_wxWindow,
55328 _swigc__p_wxWindowCreateEvent,
55329 _swigc__p_wxWindowDestroyEvent,
55330 _swigc__p_wxXPMHandler,
55331 _swigc__p_wxZipFSHandler,
55332 };
55333
55334
55335 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55336
55337 static swig_const_info swig_const_table[] = {
55338 {0, 0, 0, 0.0, 0, 0}};
55339
55340 #ifdef __cplusplus
55341 }
55342 #endif
55343 /* -----------------------------------------------------------------------------
55344 * Type initialization:
55345 * This problem is tough by the requirement that no dynamic
55346 * memory is used. Also, since swig_type_info structures store pointers to
55347 * swig_cast_info structures and swig_cast_info structures store pointers back
55348 * to swig_type_info structures, we need some lookup code at initialization.
55349 * The idea is that swig generates all the structures that are needed.
55350 * The runtime then collects these partially filled structures.
55351 * The SWIG_InitializeModule function takes these initial arrays out of
55352 * swig_module, and does all the lookup, filling in the swig_module.types
55353 * array with the correct data and linking the correct swig_cast_info
55354 * structures together.
55355 *
55356 * The generated swig_type_info structures are assigned staticly to an initial
55357 * array. We just loop though that array, and handle each type individually.
55358 * First we lookup if this type has been already loaded, and if so, use the
55359 * loaded structure instead of the generated one. Then we have to fill in the
55360 * cast linked list. The cast data is initially stored in something like a
55361 * two-dimensional array. Each row corresponds to a type (there are the same
55362 * number of rows as there are in the swig_type_initial array). Each entry in
55363 * a column is one of the swig_cast_info structures for that type.
55364 * The cast_initial array is actually an array of arrays, because each row has
55365 * a variable number of columns. So to actually build the cast linked list,
55366 * we find the array of casts associated with the type, and loop through it
55367 * adding the casts to the list. The one last trick we need to do is making
55368 * sure the type pointer in the swig_cast_info struct is correct.
55369 *
55370 * First off, we lookup the cast->type name to see if it is already loaded.
55371 * There are three cases to handle:
55372 * 1) If the cast->type has already been loaded AND the type we are adding
55373 * casting info to has not been loaded (it is in this module), THEN we
55374 * replace the cast->type pointer with the type pointer that has already
55375 * been loaded.
55376 * 2) If BOTH types (the one we are adding casting info to, and the
55377 * cast->type) are loaded, THEN the cast info has already been loaded by
55378 * the previous module so we just ignore it.
55379 * 3) Finally, if cast->type has not already been loaded, then we add that
55380 * swig_cast_info to the linked list (because the cast->type) pointer will
55381 * be correct.
55382 * ----------------------------------------------------------------------------- */
55383
55384 #ifdef __cplusplus
55385 extern "C" {
55386 #if 0
55387 } /* c-mode */
55388 #endif
55389 #endif
55390
55391 #if 0
55392 #define SWIGRUNTIME_DEBUG
55393 #endif
55394
55395 SWIGRUNTIME void
55396 SWIG_InitializeModule(void *clientdata) {
55397 size_t i;
55398 swig_module_info *module_head;
55399 static int init_run = 0;
55400
55401 clientdata = clientdata;
55402
55403 if (init_run) return;
55404 init_run = 1;
55405
55406 /* Initialize the swig_module */
55407 swig_module.type_initial = swig_type_initial;
55408 swig_module.cast_initial = swig_cast_initial;
55409
55410 /* Try and load any already created modules */
55411 module_head = SWIG_GetModule(clientdata);
55412 if (module_head) {
55413 swig_module.next = module_head->next;
55414 module_head->next = &swig_module;
55415 } else {
55416 /* This is the first module loaded */
55417 swig_module.next = &swig_module;
55418 SWIG_SetModule(clientdata, &swig_module);
55419 }
55420
55421 /* Now work on filling in swig_module.types */
55422 #ifdef SWIGRUNTIME_DEBUG
55423 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55424 #endif
55425 for (i = 0; i < swig_module.size; ++i) {
55426 swig_type_info *type = 0;
55427 swig_type_info *ret;
55428 swig_cast_info *cast;
55429
55430 #ifdef SWIGRUNTIME_DEBUG
55431 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55432 #endif
55433
55434 /* if there is another module already loaded */
55435 if (swig_module.next != &swig_module) {
55436 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55437 }
55438 if (type) {
55439 /* Overwrite clientdata field */
55440 #ifdef SWIGRUNTIME_DEBUG
55441 printf("SWIG_InitializeModule: found type %s\n", type->name);
55442 #endif
55443 if (swig_module.type_initial[i]->clientdata) {
55444 type->clientdata = swig_module.type_initial[i]->clientdata;
55445 #ifdef SWIGRUNTIME_DEBUG
55446 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55447 #endif
55448 }
55449 } else {
55450 type = swig_module.type_initial[i];
55451 }
55452
55453 /* Insert casting types */
55454 cast = swig_module.cast_initial[i];
55455 while (cast->type) {
55456 /* Don't need to add information already in the list */
55457 ret = 0;
55458 #ifdef SWIGRUNTIME_DEBUG
55459 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55460 #endif
55461 if (swig_module.next != &swig_module) {
55462 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55463 #ifdef SWIGRUNTIME_DEBUG
55464 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55465 #endif
55466 }
55467 if (ret) {
55468 if (type == swig_module.type_initial[i]) {
55469 #ifdef SWIGRUNTIME_DEBUG
55470 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55471 #endif
55472 cast->type = ret;
55473 ret = 0;
55474 } else {
55475 /* Check for casting already in the list */
55476 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55477 #ifdef SWIGRUNTIME_DEBUG
55478 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55479 #endif
55480 if (!ocast) ret = 0;
55481 }
55482 }
55483
55484 if (!ret) {
55485 #ifdef SWIGRUNTIME_DEBUG
55486 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55487 #endif
55488 if (type->cast) {
55489 type->cast->prev = cast;
55490 cast->next = type->cast;
55491 }
55492 type->cast = cast;
55493 }
55494 cast++;
55495 }
55496 /* Set entry in modules->types array equal to the type */
55497 swig_module.types[i] = type;
55498 }
55499 swig_module.types[i] = 0;
55500
55501 #ifdef SWIGRUNTIME_DEBUG
55502 printf("**** SWIG_InitializeModule: Cast List ******\n");
55503 for (i = 0; i < swig_module.size; ++i) {
55504 int j = 0;
55505 swig_cast_info *cast = swig_module.cast_initial[i];
55506 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55507 while (cast->type) {
55508 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55509 cast++;
55510 ++j;
55511 }
55512 printf("---- Total casts: %d\n",j);
55513 }
55514 printf("**** SWIG_InitializeModule: Cast List ******\n");
55515 #endif
55516 }
55517
55518 /* This function will propagate the clientdata field of type to
55519 * any new swig_type_info structures that have been added into the list
55520 * of equivalent types. It is like calling
55521 * SWIG_TypeClientData(type, clientdata) a second time.
55522 */
55523 SWIGRUNTIME void
55524 SWIG_PropagateClientData(void) {
55525 size_t i;
55526 swig_cast_info *equiv;
55527 static int init_run = 0;
55528
55529 if (init_run) return;
55530 init_run = 1;
55531
55532 for (i = 0; i < swig_module.size; i++) {
55533 if (swig_module.types[i]->clientdata) {
55534 equiv = swig_module.types[i]->cast;
55535 while (equiv) {
55536 if (!equiv->converter) {
55537 if (equiv->type && !equiv->type->clientdata)
55538 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55539 }
55540 equiv = equiv->next;
55541 }
55542 }
55543 }
55544 }
55545
55546 #ifdef __cplusplus
55547 #if 0
55548 {
55549 /* c-mode */
55550 #endif
55551 }
55552 #endif
55553
55554
55555
55556 #ifdef __cplusplus
55557 extern "C" {
55558 #endif
55559
55560 /* Python-specific SWIG API */
55561 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55562 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55563 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55564
55565 /* -----------------------------------------------------------------------------
55566 * global variable support code.
55567 * ----------------------------------------------------------------------------- */
55568
55569 typedef struct swig_globalvar {
55570 char *name; /* Name of global variable */
55571 PyObject *(*get_attr)(void); /* Return the current value */
55572 int (*set_attr)(PyObject *); /* Set the value */
55573 struct swig_globalvar *next;
55574 } swig_globalvar;
55575
55576 typedef struct swig_varlinkobject {
55577 PyObject_HEAD
55578 swig_globalvar *vars;
55579 } swig_varlinkobject;
55580
55581 SWIGINTERN PyObject *
55582 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55583 return PyString_FromString("<Swig global variables>");
55584 }
55585
55586 SWIGINTERN PyObject *
55587 swig_varlink_str(swig_varlinkobject *v) {
55588 PyObject *str = PyString_FromString("(");
55589 swig_globalvar *var;
55590 for (var = v->vars; var; var=var->next) {
55591 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55592 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55593 }
55594 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55595 return str;
55596 }
55597
55598 SWIGINTERN int
55599 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55600 PyObject *str = swig_varlink_str(v);
55601 fprintf(fp,"Swig global variables ");
55602 fprintf(fp,"%s\n", PyString_AsString(str));
55603 Py_DECREF(str);
55604 return 0;
55605 }
55606
55607 SWIGINTERN void
55608 swig_varlink_dealloc(swig_varlinkobject *v) {
55609 swig_globalvar *var = v->vars;
55610 while (var) {
55611 swig_globalvar *n = var->next;
55612 free(var->name);
55613 free(var);
55614 var = n;
55615 }
55616 }
55617
55618 SWIGINTERN PyObject *
55619 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55620 PyObject *res = NULL;
55621 swig_globalvar *var = v->vars;
55622 while (var) {
55623 if (strcmp(var->name,n) == 0) {
55624 res = (*var->get_attr)();
55625 break;
55626 }
55627 var = var->next;
55628 }
55629 if (res == NULL && !PyErr_Occurred()) {
55630 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55631 }
55632 return res;
55633 }
55634
55635 SWIGINTERN int
55636 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55637 int res = 1;
55638 swig_globalvar *var = v->vars;
55639 while (var) {
55640 if (strcmp(var->name,n) == 0) {
55641 res = (*var->set_attr)(p);
55642 break;
55643 }
55644 var = var->next;
55645 }
55646 if (res == 1 && !PyErr_Occurred()) {
55647 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55648 }
55649 return res;
55650 }
55651
55652 SWIGINTERN PyTypeObject*
55653 swig_varlink_type(void) {
55654 static char varlink__doc__[] = "Swig var link object";
55655 static PyTypeObject varlink_type;
55656 static int type_init = 0;
55657 if (!type_init) {
55658 const PyTypeObject tmp
55659 = {
55660 PyObject_HEAD_INIT(NULL)
55661 0, /* Number of items in variable part (ob_size) */
55662 (char *)"swigvarlink", /* Type name (tp_name) */
55663 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55664 0, /* Itemsize (tp_itemsize) */
55665 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55666 (printfunc) swig_varlink_print, /* Print (tp_print) */
55667 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55668 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55669 0, /* tp_compare */
55670 (reprfunc) swig_varlink_repr, /* tp_repr */
55671 0, /* tp_as_number */
55672 0, /* tp_as_sequence */
55673 0, /* tp_as_mapping */
55674 0, /* tp_hash */
55675 0, /* tp_call */
55676 (reprfunc)swig_varlink_str, /* tp_str */
55677 0, /* tp_getattro */
55678 0, /* tp_setattro */
55679 0, /* tp_as_buffer */
55680 0, /* tp_flags */
55681 varlink__doc__, /* tp_doc */
55682 0, /* tp_traverse */
55683 0, /* tp_clear */
55684 0, /* tp_richcompare */
55685 0, /* tp_weaklistoffset */
55686 #if PY_VERSION_HEX >= 0x02020000
55687 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55688 #endif
55689 #if PY_VERSION_HEX >= 0x02030000
55690 0, /* tp_del */
55691 #endif
55692 #ifdef COUNT_ALLOCS
55693 0,0,0,0 /* tp_alloc -> tp_next */
55694 #endif
55695 };
55696 varlink_type = tmp;
55697 varlink_type.ob_type = &PyType_Type;
55698 type_init = 1;
55699 }
55700 return &varlink_type;
55701 }
55702
55703 /* Create a variable linking object for use later */
55704 SWIGINTERN PyObject *
55705 SWIG_Python_newvarlink(void) {
55706 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55707 if (result) {
55708 result->vars = 0;
55709 }
55710 return ((PyObject*) result);
55711 }
55712
55713 SWIGINTERN void
55714 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55715 swig_varlinkobject *v = (swig_varlinkobject *) p;
55716 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55717 if (gv) {
55718 size_t size = strlen(name)+1;
55719 gv->name = (char *)malloc(size);
55720 if (gv->name) {
55721 strncpy(gv->name,name,size);
55722 gv->get_attr = get_attr;
55723 gv->set_attr = set_attr;
55724 gv->next = v->vars;
55725 }
55726 }
55727 v->vars = gv;
55728 }
55729
55730 SWIGINTERN PyObject *
55731 SWIG_globals() {
55732 static PyObject *_SWIG_globals = 0;
55733 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55734 return _SWIG_globals;
55735 }
55736
55737 /* -----------------------------------------------------------------------------
55738 * constants/methods manipulation
55739 * ----------------------------------------------------------------------------- */
55740
55741 /* Install Constants */
55742 SWIGINTERN void
55743 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55744 PyObject *obj = 0;
55745 size_t i;
55746 for (i = 0; constants[i].type; ++i) {
55747 switch(constants[i].type) {
55748 case SWIG_PY_POINTER:
55749 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55750 break;
55751 case SWIG_PY_BINARY:
55752 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55753 break;
55754 default:
55755 obj = 0;
55756 break;
55757 }
55758 if (obj) {
55759 PyDict_SetItemString(d, constants[i].name, obj);
55760 Py_DECREF(obj);
55761 }
55762 }
55763 }
55764
55765 /* -----------------------------------------------------------------------------*/
55766 /* Fix SwigMethods to carry the callback ptrs when needed */
55767 /* -----------------------------------------------------------------------------*/
55768
55769 SWIGINTERN void
55770 SWIG_Python_FixMethods(PyMethodDef *methods,
55771 swig_const_info *const_table,
55772 swig_type_info **types,
55773 swig_type_info **types_initial) {
55774 size_t i;
55775 for (i = 0; methods[i].ml_name; ++i) {
55776 const char *c = methods[i].ml_doc;
55777 if (c && (c = strstr(c, "swig_ptr: "))) {
55778 int j;
55779 swig_const_info *ci = 0;
55780 const char *name = c + 10;
55781 for (j = 0; const_table[j].type; ++j) {
55782 if (strncmp(const_table[j].name, name,
55783 strlen(const_table[j].name)) == 0) {
55784 ci = &(const_table[j]);
55785 break;
55786 }
55787 }
55788 if (ci) {
55789 size_t shift = (ci->ptype) - types;
55790 swig_type_info *ty = types_initial[shift];
55791 size_t ldoc = (c - methods[i].ml_doc);
55792 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55793 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55794 if (ndoc) {
55795 char *buff = ndoc;
55796 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55797 if (ptr) {
55798 strncpy(buff, methods[i].ml_doc, ldoc);
55799 buff += ldoc;
55800 strncpy(buff, "swig_ptr: ", 10);
55801 buff += 10;
55802 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55803 methods[i].ml_doc = ndoc;
55804 }
55805 }
55806 }
55807 }
55808 }
55809 }
55810
55811 #ifdef __cplusplus
55812 }
55813 #endif
55814
55815 /* -----------------------------------------------------------------------------*
55816 * Partial Init method
55817 * -----------------------------------------------------------------------------*/
55818
55819 #ifdef __cplusplus
55820 extern "C"
55821 #endif
55822 SWIGEXPORT void SWIG_init(void) {
55823 PyObject *m, *d;
55824
55825 /* Fix SwigMethods to carry the callback ptrs when needed */
55826 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55827
55828 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55829 d = PyModule_GetDict(m);
55830
55831 SWIG_InitializeModule(0);
55832 SWIG_InstallConstants(d,swig_const_table);
55833
55834
55835
55836 #ifndef wxPyUSE_EXPORT
55837 // Make our API structure a CObject so other modules can import it
55838 // from this module.
55839 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55840 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55841 Py_XDECREF(cobj);
55842 #endif
55843
55844 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55845 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55846 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55847 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55848 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55849 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55850 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55851 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55852 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55853 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55854 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55855 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55856 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55857 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55858 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55859 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55860 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55861 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55862 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55863 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55864 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55865 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55866 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55867 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55868 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55869 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55870 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55871 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55872 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55873 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55874 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55875 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55876 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55877 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55878 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55879 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55880 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55881 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55882 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55883 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55884 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55885 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55886 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55887 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55888 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55889 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55890 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55891 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55892 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55893 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55894 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55895 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55896 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55897 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55898 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55899 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55900 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55901 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55902 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55903 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55904 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55905 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55906 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55907 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55908 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55909 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55910 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55911 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55912 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55913 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55914 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55915 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55916 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55917 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55918 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55919 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55920 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55921 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55922 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55923 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55924 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55925 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55926 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55927 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55928 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55929 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55930 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55931 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55932 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55933 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55934 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55935 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55936 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55937 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55938 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55939 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55940 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55941 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55942 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55943 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55944 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55945 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55946 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55947 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55948 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55949 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55950 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55951 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55952 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55953 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55954 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55955 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55956 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55957 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55958 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55959 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55960 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55961 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55962 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55963 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55964 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
55965 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
55966 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55967 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55968 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55969 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55970 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55971 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55972 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55973 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55974 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55975 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55976 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55977 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55978 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55979 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55980 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55981 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55982 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55983 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55984 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55985 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55986 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55987 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55988 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55989 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55990 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55991 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55992 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55993 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55994 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55995 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55996 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55997 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55998 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55999 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56000 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56001 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56002 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56003 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56004 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56005 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56006 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56007 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56008 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56009 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56010 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56011 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56012 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56013 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56014 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56015 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56016 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56017 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56018 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56019 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56020 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56021 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56022 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56023 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56024 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56025 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56026 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56027 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56028 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56029 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56030 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56031 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56032 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56033 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56034 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56035 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56036 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56037 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56038 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56039 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56040 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56041 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56042 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56043 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56044 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56045 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56046 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56047 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56048 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56049 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56050 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56051 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56052 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56053 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56054 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56055 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56056 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56057 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56058 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56059 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56060 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56061 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56062 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56063 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56064 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56065 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56066 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56067 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56068 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56069 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56070 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56071 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56072 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56073 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56074 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56075 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56076 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56077 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56078 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56079 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56080 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56081 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56082 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56083 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56084 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56085 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56086 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56087 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56088 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56089 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56090 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56091 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56092 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56093 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56094 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56095 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56096 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56097 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56098 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56099 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56100 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56101 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56102 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56103 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56104 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56105 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56106 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56107 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56108 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56109 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56110 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56111 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56112 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56113 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56114 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56115 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56116 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56117 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56118 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56119 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56120 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56121 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56122 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56123 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56124 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56125 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56126 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56127 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56128 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56129 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56130 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56131 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56132 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56133 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56134 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56135 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56136 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56137 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56138 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56139 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56140 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56141 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56142 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56143 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56144 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56145 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56146 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56147 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56148 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56149 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56150 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56151 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56152 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56153 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56154 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56155 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56156 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56157 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56158 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56159 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56160 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56161 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56162 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56163 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56164 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56165 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56166 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56167 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56168 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56169 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56170 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56171 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56172 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56173 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56174 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56175 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56176 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56177 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56178 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56179 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56180 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56181 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56182 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56183 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56184 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56185 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56186 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56187 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56188 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56189 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56190 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56191 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56192 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56193 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56194 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56195 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56196 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56197 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56198 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56199 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56200 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56201 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56202 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56203 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56204 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56205 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56206 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56207 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56208 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56209 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56210 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56211 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56212 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56213 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56214 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56215 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56216 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56217 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56218 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56219 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56220 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56221 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56222 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56223 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56224 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56225 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56226 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56227 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56228 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56229 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56230 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56231 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56232 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56233 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56234 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56235 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56236 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56237 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56238 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56239 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56240 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56241 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56242 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56243 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56244 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56245 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56246 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56247 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56248 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56249 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56250 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56251 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56252 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56253 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56254 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56255 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56256 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56257 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56258 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56259 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56260 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56261 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56262 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56263 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56264 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56265 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56266 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56267 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56268 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56269 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56270 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56271 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56272 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56273 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56274 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56275 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56276 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56277 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56278 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56279 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56280 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56281 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56282 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56283 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56284 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56285 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56286 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56287 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56288 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56289 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56290 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56291 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56292 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56293 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56294 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56295 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56296 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56297 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56298 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56299 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56300 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56301 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56302 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56303 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56304 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56305 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56306 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56307 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56308 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56309 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56310 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56311 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56312 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56313 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56314 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56315 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56316 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56317 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56318 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56319 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56320 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56321 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56322 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56323 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56324 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56325 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56326 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56327 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56328 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56329 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56330 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56331 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56332 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56333 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56334 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56335 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56336 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56337 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56338 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56339 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56340 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56341 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56342 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56343 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56344 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56345 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56346 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56347 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56348 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56349 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56350 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56351 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56352 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56353 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56354 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56355 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56356 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56357 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56358 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56359 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56360 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56361 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56362 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56363 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56364 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56365 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56366 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56367 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56368 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56369 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56370 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56371 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56372 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56373 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56374 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56375 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56376 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56377 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56378 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56379 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56380 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56381 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56382 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56383 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56384 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56385 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56386 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56387 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56388 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56389 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56390 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56391 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56392 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56393 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56394 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56395 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56396 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56397 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56398 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56399 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56400 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56401 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56402 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56403 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56404 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56405 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56406 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56407 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56408 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56409 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56410 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56411 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56412 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56413 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56414 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56415 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56416 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56417 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56418 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56419 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56420 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56421 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56422 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56423 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56424 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56425 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56426 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56427 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56428 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56429 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56430 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56431 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56432 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56433 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56434 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56435 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56436 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56437 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56438 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56439 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56440 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56441 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56442 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56443 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56444 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56445 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56446 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56447 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56448 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56449 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56450 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56451 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56452 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56453 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56454 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56455 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56456 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56457 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56458 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56459 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56460 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56461 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56462 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56463 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56464 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56465 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56466 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56467 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56468 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56469 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56470 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56471 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56472 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56473 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56474 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56475 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56476 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56477 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56478 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56479 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56480 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56481 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56482 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56483 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56484 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56485 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56486 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56487 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56488 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56489 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56490 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56491 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56492 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56493 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56494 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56495 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56496 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56497 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56498 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56499 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56500 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56501 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56502 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56503 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56504 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56505 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56506 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56507 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56508 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56509
56510 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56511
56512
56513 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56514
56515 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56516 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56517 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56518 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56519 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56520 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56521 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56522 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56523 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56524 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56525 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56526 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56527 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56528 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56529 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56530 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56531 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56532 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56533 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56534 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56535 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56536 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56537 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56538 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56539 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56540 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56541 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56542 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56543 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56544 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56545 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56546 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56547 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56548 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56549 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56550 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56551 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56552 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56553 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56554 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56555 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56556 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56557 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56558 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56559 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56560 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56561 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56562 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56563 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56564 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56565 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56566 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56567 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56568 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56569 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56570 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56571 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56572 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56573 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56574 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56575 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56576 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56577 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56578 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56579 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56580 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56581 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56582 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56583 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56584 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56585 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56586 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56587 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56588 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56589 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56590 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56591 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56592 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56593 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56594 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56595 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56596 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56597 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56598 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56599 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56600 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56601 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56602 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56603 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56604 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56605 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56606 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56607 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56608 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56609 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56610 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56611 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56612 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56613 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56614 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56615 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56616 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56617 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56618 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56619 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56620 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56621 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56622 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56623 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56624 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56625 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56626 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56627 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56628 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56629 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56630 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56631 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56632 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56633 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56634 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56635 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56636 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56637 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56638 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56639 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56640 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56641 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56642 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56643 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56644 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56645 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56646 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56647 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56648 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56649 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56650 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56651 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56652 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56653 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56654 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56655 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56656 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56657 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56658 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56659 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56660 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56661 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56662 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56663 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56664 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56665 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56666 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56667 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56668 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56669 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56670 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56671 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56672 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56673 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56674 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56675 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56676 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56677 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56678 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56679 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56680 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56681 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56682 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56683 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56684 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56685 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56686 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56687 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56688 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56689 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56690 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56691 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56692 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56693 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56694 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56695 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56696 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56697 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56698 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56699 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56700 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56701 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56702 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56703 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56704 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56705 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56706 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56707 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56708 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56709 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56710 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56711 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56712 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56713 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56714 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56715 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56716 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56717 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56718 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56719 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56720 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56721
56722 // Initialize threading, some globals and such
56723 __wxPyPreStart(d);
56724
56725
56726 // Although these are defined in __version__ they need to be here too so
56727 // that an assert can be done to ensure that the wxPython and the wxWindows
56728 // versions match.
56729 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56730 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56731 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56732
56733 }
56734
wxWidgets (Impactor)